Generalize source entry

pkg/analyzer/test/generated/engine_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.engine_test;
 
 import 'dart:collection';
@@ skipping 525 matching lines @@
     }
   }
 
   void test_computeResolvableCompilationUnit_valid() {
     Source source = _addSource("/lib.dart", "library lib;");
     CompilationUnit parsedUnit = _context.parseCompilationUnit(source);
     JUnitTestCase.assertNotNull(parsedUnit);
     CompilationUnit resolvedUnit =
         _context.computeResolvableCompilationUnit(source);
     JUnitTestCase.assertNotNull(resolvedUnit);
-    JUnitTestCase.assertNotSame(parsedUnit, resolvedUnit);
+    JUnitTestCase.assertSame(parsedUnit, resolvedUnit);
   }
 
   void test_dispose() {
     JUnitTestCase.assertFalse(_context.isDisposed);
     _context.dispose();
     JUnitTestCase.assertTrue(_context.isDisposed);
   }
 
   void test_exists_false() {
     TestSource source = new TestSource();
@@ skipping 1636 matching lines @@
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
     EngineTestCase.assertLength(5, entry.allErrors);
   }
 
   void test_getResolvableCompilationUnit_none() {
     DartEntry entry = new DartEntry();
     JUnitTestCase.assertNull(entry.resolvableCompilationUnit);
   }
 
   void test_getResolvableCompilationUnit_parsed_accessed() {
-    String importUri = "f1.dart";
+    Source librarySource = new TestSource("/lib.dart");
+    String importUri = "/f1.dart";
     Source importSource = new TestSource(importUri);
     ImportDirective importDirective =
         AstFactory.importDirective3(importUri, null, []);
     importDirective.source = importSource;
     importDirective.uriContent = importUri;
-    String exportUri = "f2.dart";
+    String exportUri = "/f2.dart";
     Source exportSource = new TestSource(exportUri);
     ExportDirective exportDirective =
         AstFactory.exportDirective2(exportUri, []);
     exportDirective.source = exportSource;
     exportDirective.uriContent = exportUri;
-    String partUri = "f3.dart";
+    String partUri = "/f3.dart";
     Source partSource = new TestSource(partUri);
     PartDirective partDirective = AstFactory.partDirective2(partUri);
     partDirective.source = partSource;
     partDirective.uriContent = partUri;
     CompilationUnit unit =
         AstFactory.compilationUnit3([importDirective, exportDirective, partDirective]);
     DartEntry entry = new DartEntry();
     entry.setValue(DartEntry.PARSED_UNIT, unit);
     entry.getValue(DartEntry.PARSED_UNIT);
     CompilationUnit result = entry.resolvableCompilationUnit;
+    JUnitTestCase.assertSame(unit, result);
+    entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
+    result = entry.resolvableCompilationUnit;
     JUnitTestCase.assertNotSame(unit, result);
     NodeList<Directive> directives = result.directives;
     ImportDirective resultImportDirective = directives[0] as ImportDirective;
     JUnitTestCase.assertEquals(importUri, resultImportDirective.uriContent);
     JUnitTestCase.assertSame(importSource, resultImportDirective.source);
     ExportDirective resultExportDirective = directives[1] as ExportDirective;
     JUnitTestCase.assertEquals(exportUri, resultExportDirective.uriContent);
     JUnitTestCase.assertSame(exportSource, resultExportDirective.source);
     PartDirective resultPartDirective = directives[2] as PartDirective;
     JUnitTestCase.assertEquals(partUri, resultPartDirective.uriContent);
@@ skipping 44 matching lines @@
     PartDirective resultPartDirective = directives[2] as PartDirective;
     JUnitTestCase.assertEquals(partUri, resultPartDirective.uriContent);
     JUnitTestCase.assertSame(partSource, resultPartDirective.source);
   }
 
   void test_getStateInLibrary_invalid_element() {
     DartEntry entry = new DartEntry();
     try {
       entry.getStateInLibrary(DartEntry.ELEMENT, new TestSource());
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_getState_invalid_resolutionErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.getState(DartEntry.RESOLUTION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_getState_invalid_verificationErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.getState(DartEntry.VERIFICATION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
+  void test_getValue_containingLibraries() {
+    Source testSource = new TestSource();
+    DartEntry entry = new DartEntry();
+    List<Source> value = entry.containingLibraries;
+    EngineTestCase.assertLength(0, value);
+    entry.addContainingLibrary(testSource);
+    value = entry.containingLibraries;
+    EngineTestCase.assertLength(1, value);
+    JUnitTestCase.assertEquals(testSource, value[0]);
+    entry.removeContainingLibrary(testSource);
+    value = entry.containingLibraries;
+    EngineTestCase.assertLength(0, value);
+  }
+
   void test_getValueInLibrary_invalid_element() {
     DartEntry entry = new DartEntry();
     try {
       entry.getValueInLibrary(DartEntry.ELEMENT, new TestSource());
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_getValueInLibrary_invalid_resolutionErrors_multiple() {
     Source source1 = new TestSource();
     Source source2 = new TestSource();
     Source source3 = new TestSource();
     DartEntry entry = new DartEntry();
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source1,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source2,
         AstFactory.compilationUnit());
     entry.setValueInLibrary(
         DartEntry.RESOLVED_UNIT,
         source3,
         AstFactory.compilationUnit());
     try {
       entry.getValueInLibrary(DartEntry.ELEMENT, source3);
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
-  void test_getValue_containingLibraries() {
-    Source testSource = new TestSource();
-    DartEntry entry = new DartEntry();
-    List<Source> value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
-    EngineTestCase.assertLength(0, value);
-    entry.addContainingLibrary(testSource);
-    value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
-    EngineTestCase.assertLength(1, value);
-    JUnitTestCase.assertEquals(testSource, value[0]);
-    entry.removeContainingLibrary(testSource);
-    value = entry.getValue(DartEntry.CONTAINING_LIBRARIES);
-    EngineTestCase.assertLength(0, value);
-  }
-
   void test_getValue_invalid_resolutionErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.getValue(DartEntry.RESOLUTION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
     }
   }
 
   void test_getValue_invalid_verificationErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.getValue(DartEntry.VERIFICATION_ERRORS);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_hasInvalidData_false() {
     DartEntry entry = new DartEntry();
     entry.recordScanError(new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertFalse(entry.hasInvalidData(DartEntry.ELEMENT));
     JUnitTestCase.assertFalse(
         entry.hasInvalidData(DartEntry.EXPORTED_LIBRARIES));
@@ skipping 426 matching lines @@
     // any way of setting the state for data associated with a library we
     // don't know anything about.
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILT_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.HINTS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
-  void test_recordParseInProcess() {
-    DartEntry entry = new DartEntry();
-    entry.recordParseInProcess();
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(DartEntry.PARSE_ERRORS));
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(DartEntry.PARSED_UNIT));
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(DartEntry.SOURCE_KIND));
-  }
-
   void test_recordResolutionError() {
     //    Source source = new TestSource();
     DartEntry entry = new DartEntry();
     entry.recordResolutionError(
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
         CacheState.INVALID,
         entry.getState(SourceEntry.CONTENT));
     JUnitTestCase.assertSame(
         CacheState.ERROR,
@@ skipping 160 matching lines @@
     // any way of setting the state for data associated with a library we
     // don't know anything about.
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.BUILT_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.HINTS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, source));
 //    assertSame(CacheState.ERROR, entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, source));
   }
 
-  void test_recordScanInProcess() {
-    DartEntry entry = new DartEntry();
-    entry.recordScanInProcess();
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(SourceEntry.LINE_INFO));
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(DartEntry.SCAN_ERRORS));
-    JUnitTestCase.assertSame(
-        CacheState.IN_PROCESS,
-        entry.getState(DartEntry.TOKEN_STREAM));
-  }
-
   void test_recordVerificationErrorInLibrary() {
     // TODO(brianwilkerson) This test should set the state for two libraries,
     // record an error in one library, then verify that the data for the other
     // library is still valid.
     Source source = new TestSource();
     DartEntry entry = new DartEntry();
     entry.recordVerificationErrorInLibrary(
         source,
         new CaughtException(new AnalysisException(), null));
     JUnitTestCase.assertSame(
@@ skipping 140 matching lines @@
 
   void test_setState_includedParts() {
     state2 = DartEntry.INCLUDED_PARTS;
   }
 
   void test_setState_invalid_element() {
     DartEntry entry = new DartEntry();
     try {
       entry.setStateInLibrary(DartEntry.ELEMENT, null, CacheState.FLUSHED);
       JUnitTestCase.fail("Expected IllegalArgumentException for ELEMENT");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_setState_invalid_resolutionErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.setState(DartEntry.RESOLUTION_ERRORS, CacheState.FLUSHED);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for RESOLUTION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_setState_invalid_validState() {
     DartEntry entry = new DartEntry();
     try {
       entry.setState(SourceEntry.LINE_INFO, CacheState.VALID);
       JUnitTestCase.fail(
-          "Expected IllegalArgumentException for a state of VALID");
-    } on IllegalArgumentException catch (exception) {
+          "Expected ArgumentError for a state of VALID");
+    } on ArgumentError catch (exception) {
     }
   }
 
   void test_setState_invalid_verificationErrors() {
     DartEntry entry = new DartEntry();
     try {
       entry.setState(DartEntry.VERIFICATION_ERRORS, CacheState.FLUSHED);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for VERIFICATION_ERRORS");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
       // Expected
-    }
-  }
+     }
+   }
 
   void test_setState_isClient() {
     state2 = DartEntry.IS_CLIENT;
   }
 
   void test_setState_isLaunchable() {
     state2 = DartEntry.IS_LAUNCHABLE;
   }
 
   void test_setState_lineInfo() {
@@ skipping 685 matching lines @@
         HtmlEntry.HINTS,
         <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE, [])]);
   }
 
   void test_setValue_illegal() {
     HtmlEntry entry = new HtmlEntry();
     try {
       entry.setValue(DartEntry.ELEMENT, null);
       JUnitTestCase.fail(
           "Expected IllegalArgumentException for DartEntry.ELEMENT");
-    } on IllegalArgumentException catch (exception) {
+    } on ArgumentError catch (exception) {
     }
   }
 
   void test_setValue_lineInfo() {
     _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
   }
 
   void test_setValue_parseErrors() {
     _setValue(
         HtmlEntry.PARSE_ERRORS,
@@ skipping 25 matching lines @@
 
   void test_setValue_resolutionErrors() {
     _setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])]);
   }
 
   HtmlEntry _entryWithValidState() {
     HtmlEntry entry = new HtmlEntry();
+    entry.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
+    entry.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
     entry.setValue(HtmlEntry.ANGULAR_ERRORS, null);
     entry.setValue(HtmlEntry.ELEMENT, null);
     entry.setValue(HtmlEntry.HINTS, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(HtmlEntry.PARSE_ERRORS, null);
     entry.setValue(HtmlEntry.PARSED_UNIT, null);
     entry.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, null);
     entry.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, null);
     entry.setValue(HtmlEntry.REFERENCED_LIBRARIES, null);
     entry.setValue(HtmlEntry.RESOLUTION_ERRORS, null);
@@ skipping 3147 matching lines @@
   }
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }