| // 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. |
| |
| library engine.engine_test; |
| |
| import 'dart:async'; |
| import 'dart:collection'; |
| |
| import 'package:analyzer/file_system/memory_file_system.dart'; |
| import 'package:analyzer/src/cancelable_future.dart'; |
| import 'package:analyzer/src/context/cache.dart' show CacheEntry; |
| import 'package:analyzer/src/generated/ast.dart'; |
| import 'package:analyzer/src/generated/constant.dart'; |
| import 'package:analyzer/src/generated/element.dart'; |
| import 'package:analyzer/src/generated/engine.dart'; |
| import 'package:analyzer/src/generated/error.dart'; |
| import 'package:analyzer/src/generated/html.dart' as ht; |
| import 'package:analyzer/src/generated/java_core.dart'; |
| import 'package:analyzer/src/generated/java_engine.dart'; |
| import 'package:analyzer/src/generated/java_engine_io.dart'; |
| import 'package:analyzer/src/generated/java_io.dart'; |
| import 'package:analyzer/src/generated/parser.dart'; |
| import 'package:analyzer/src/generated/resolver.dart'; |
| import 'package:analyzer/src/generated/scanner.dart'; |
| import 'package:analyzer/src/generated/sdk.dart'; |
| import 'package:analyzer/src/generated/sdk_io.dart'; |
| import 'package:analyzer/src/generated/source_io.dart'; |
| import 'package:analyzer/src/generated/testing/ast_factory.dart'; |
| import 'package:analyzer/src/generated/testing/element_factory.dart'; |
| import 'package:analyzer/src/generated/utilities_collection.dart'; |
| import 'package:analyzer/src/services/lint.dart'; |
| import 'package:analyzer/src/string_source.dart'; |
| import 'package:analyzer/task/model.dart' hide AnalysisTask, WorkManager; |
| import 'package:html/dom.dart' show Document; |
| import 'package:path/path.dart' as pathos; |
| import 'package:typed_mock/typed_mock.dart'; |
| import 'package:unittest/unittest.dart'; |
| import 'package:watcher/src/utils.dart'; |
| |
| import '../reflective_tests.dart'; |
| import '../utils.dart'; |
| import 'all_the_rest_test.dart'; |
| import 'resolver_test.dart'; |
| import 'test_support.dart'; |
| |
| main() { |
| initializeTestEnvironment(); |
| // Tests for the classes used in both old and new analysis implementations. |
| runReflectiveTests(SourcesChangedEventTest); |
| // Tests for the classes used in the old analysis implementation. |
| if (!AnalysisEngine.instance.useTaskModel) { |
| runReflectiveTests(AnalysisCacheTest); |
| runReflectiveTests(AnalysisContextImplTest); |
| runReflectiveTests(AnalysisTaskTest); |
| runReflectiveTests(AnalysisOptionsImplTest); |
| runReflectiveTests(DartEntryTest); |
| runReflectiveTests(GenerateDartErrorsTaskTest); |
| runReflectiveTests(GenerateDartHintsTaskTest); |
| runReflectiveTests(GenerateDartLintsTaskTest); |
| runReflectiveTests(GetContentTaskTest); |
| runReflectiveTests(HtmlEntryTest); |
| runReflectiveTests(IncrementalAnalysisCacheTest); |
| runReflectiveTests(IncrementalAnalysisTaskTest); |
| runReflectiveTests(LintGeneratorTest); |
| runReflectiveTests(ParseDartTaskTest); |
| runReflectiveTests(ParseHtmlTaskTest); |
| runReflectiveTests(PartitionManagerTest); |
| runReflectiveTests(ResolveDartLibraryTaskTest); |
| runReflectiveTests(ResolveDartUnitTaskTest); |
| runReflectiveTests(ResolveHtmlTaskTest); |
| runReflectiveTests(ScanDartTaskTest); |
| runReflectiveTests(SdkCachePartitionTest); |
| runReflectiveTests(UniversalCachePartitionTest); |
| runReflectiveTests(WorkManagerTest); |
| } |
| } |
| |
| @reflectiveTest |
| class AnalysisCacheTest extends EngineTestCase { |
| void test_creation() { |
| expect(new AnalysisCache(new List<CachePartition>(0)), isNotNull); |
| } |
| |
| void test_get() { |
| AnalysisCache cache = new AnalysisCache(new List<CachePartition>(0)); |
| TestSource source = new TestSource(); |
| expect(cache.get(source), isNull); |
| } |
| |
| void test_iterator() { |
| CachePartition partition = |
| new UniversalCachePartition(null, 8, new DefaultRetentionPolicy()); |
| AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]); |
| TestSource source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| cache.put(source, entry); |
| MapIterator<Source, SourceEntry> iterator = cache.iterator(); |
| expect(iterator.moveNext(), isTrue); |
| expect(iterator.key, same(source)); |
| expect(iterator.value, same(entry)); |
| expect(iterator.moveNext(), isFalse); |
| } |
| |
| /** |
| * Verify that if multiple Source objects refer to the same file via |
| * different URIs, they are treated as separate entries in the cache. |
| */ |
| void test_lookup_distinguishes_uris() { |
| CachePartition partition = |
| new UniversalCachePartition(null, 8, new DefaultRetentionPolicy()); |
| AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]); |
| JavaFile file = new JavaFile('baz.dart'); |
| Source source1 = new FileBasedSource(file); |
| Source source2 = |
| new FileBasedSource(file, Uri.parse('package:foo/baz.dart')); |
| Source source3 = |
| new FileBasedSource(file, Uri.parse('package:bar/baz.dart')); |
| DartEntry entry1 = new DartEntry(); |
| DartEntry entry2 = new DartEntry(); |
| DartEntry entry3 = new DartEntry(); |
| cache.put(source1, entry1); |
| cache.put(source2, entry2); |
| cache.put(source3, entry3); |
| expect(cache.get(source1), same(entry1)); |
| expect(cache.get(source2), same(entry2)); |
| expect(cache.get(source3), same(entry3)); |
| } |
| |
| void test_put_noFlush() { |
| CachePartition partition = |
| new UniversalCachePartition(null, 8, new DefaultRetentionPolicy()); |
| AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]); |
| TestSource source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| cache.put(source, entry); |
| expect(cache.get(source), same(entry)); |
| } |
| |
| void test_setMaxCacheSize() { |
| CachePartition partition = new UniversalCachePartition( |
| null, 8, new _AnalysisCacheTest_test_setMaxCacheSize()); |
| AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]); |
| int size = 6; |
| for (int i = 0; i < size; i++) { |
| Source source = new TestSource("/test$i.dart"); |
| DartEntry entry = new DartEntry(); |
| entry.setValue(DartEntry.PARSED_UNIT, null); |
| cache.put(source, entry); |
| cache.accessedAst(source); |
| } |
| _assertNonFlushedCount(size, cache); |
| int newSize = size - 2; |
| partition.maxCacheSize = newSize; |
| _assertNonFlushedCount(newSize, cache); |
| } |
| |
| void test_size() { |
| CachePartition partition = |
| new UniversalCachePartition(null, 8, new DefaultRetentionPolicy()); |
| AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]); |
| int size = 4; |
| for (int i = 0; i < size; i++) { |
| Source source = new TestSource("/test$i.dart"); |
| cache.put(source, new DartEntry()); |
| cache.accessedAst(source); |
| } |
| expect(cache.size(), size); |
| } |
| |
| void _assertNonFlushedCount(int expectedCount, AnalysisCache cache) { |
| int nonFlushedCount = 0; |
| MapIterator<Source, SourceEntry> iterator = cache.iterator(); |
| while (iterator.moveNext()) { |
| if (iterator.value.getState(DartEntry.PARSED_UNIT) != |
| CacheState.FLUSHED) { |
| nonFlushedCount++; |
| } |
| } |
| expect(nonFlushedCount, expectedCount); |
| } |
| } |
| |
| @reflectiveTest |
| class AnalysisContextImplTest extends EngineTestCase { |
| /** |
| * An analysis context whose source factory is [sourceFactory]. |
| */ |
| AnalysisContextImpl _context; |
| |
| /** |
| * The source factory associated with the analysis [context]. |
| */ |
| SourceFactory _sourceFactory; |
| |
| void fail_performAnalysisTask_importedLibraryDelete_html() { |
| Source htmlSource = _addSource( |
| "/page.html", |
| r''' |
| <html><body><script type="application/dart"> |
| import 'libB.dart'; |
| main() {print('hello dart');} |
| </script></body></html>'''); |
| Source libBSource = _addSource("/libB.dart", "library libB;"); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull, |
| reason: "htmlUnit resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull, |
| reason: "libB resolved 1"); |
| expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(htmlSource)), |
| isTrue, |
| reason: "htmlSource doesn't have errors"); |
| // remove libB.dart content and analyze |
| _context.setContents(libBSource, null); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull, |
| reason: "htmlUnit resolved 1"); |
| AnalysisErrorInfo errors = _context.getErrors(htmlSource); |
| expect(_hasAnalysisErrorWithErrorSeverity(errors), isTrue, |
| reason: "htmlSource has an error"); |
| } |
| |
| void fail_recordLibraryElements() { |
| fail("Implement this"); |
| } |
| |
| @override |
| void setUp() { |
| _context = new AnalysisContextImpl(); |
| _sourceFactory = new SourceFactory([ |
| new DartUriResolver(DirectoryBasedDartSdk.defaultSdk), |
| new FileUriResolver() |
| ]); |
| _context.sourceFactory = _sourceFactory; |
| AnalysisOptionsImpl options = |
| new AnalysisOptionsImpl.from(_context.analysisOptions); |
| options.cacheSize = 256; |
| _context.analysisOptions = options; |
| } |
| |
| @override |
| void tearDown() { |
| _context = null; |
| _sourceFactory = null; |
| super.tearDown(); |
| } |
| |
| Future test_applyChanges_add() { |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| expect(_context.sourcesNeedingProcessing.isEmpty, isTrue); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| _context.applyChanges(changeSet); |
| expect(_context.sourcesNeedingProcessing.contains(source), isTrue); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| Future test_applyChanges_change() { |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| expect(_context.sourcesNeedingProcessing.isEmpty, isTrue); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet1 = new ChangeSet(); |
| changeSet1.addedSource(source); |
| _context.applyChanges(changeSet1); |
| expect(_context.sourcesNeedingProcessing.contains(source), isTrue); |
| Source source2 = |
| new FileBasedSource(FileUtilities2.createFile("/test2.dart")); |
| ChangeSet changeSet2 = new ChangeSet(); |
| changeSet2.addedSource(source2); |
| changeSet2.changedSource(source); |
| _context.applyChanges(changeSet2); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(wereSourcesAdded: true, changedSources: [source]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| Future test_applyChanges_change_content() { |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| expect(_context.sourcesNeedingProcessing.isEmpty, isTrue); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet1 = new ChangeSet(); |
| changeSet1.addedSource(source); |
| _context.applyChanges(changeSet1); |
| expect(_context.sourcesNeedingProcessing.contains(source), isTrue); |
| Source source2 = |
| new FileBasedSource(FileUtilities2.createFile("/test2.dart")); |
| ChangeSet changeSet2 = new ChangeSet(); |
| changeSet2.addedSource(source2); |
| changeSet2.changedContent(source, 'library test;'); |
| _context.applyChanges(changeSet2); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(wereSourcesAdded: true, changedSources: [source]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| void test_applyChanges_change_flush_element() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source librarySource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| int a = 0;'''); |
| expect(_context.computeLibraryElement(librarySource), isNotNull); |
| _context.setContents( |
| librarySource, |
| r''' |
| library lib; |
| int aa = 0;'''); |
| expect(_context.getLibraryElement(librarySource), isNull); |
| } |
| |
| Future test_applyChanges_change_multiple() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| _sourceFactory = _context.sourceFactory; |
| String libraryContents1 = r''' |
| library lib; |
| part 'part.dart'; |
| int a = 0;'''; |
| Source librarySource = _addSource("/lib.dart", libraryContents1); |
| String partContents1 = r''' |
| part of lib; |
| int b = a;'''; |
| Source partSource = _addSource("/part.dart", partContents1); |
| _context.computeLibraryElement(librarySource); |
| String libraryContents2 = r''' |
| library lib; |
| part 'part.dart'; |
| int aa = 0;'''; |
| _context.setContents(librarySource, libraryContents2); |
| String partContents2 = r''' |
| part of lib; |
| int b = aa;'''; |
| _context.setContents(partSource, partContents2); |
| _context.computeLibraryElement(librarySource); |
| CompilationUnit libraryUnit = |
| _context.resolveCompilationUnit2(librarySource, librarySource); |
| CompilationUnit partUnit = |
| _context.resolveCompilationUnit2(partSource, librarySource); |
| TopLevelVariableDeclaration declaration = |
| libraryUnit.declarations[0] as TopLevelVariableDeclaration; |
| Element declarationElement = declaration.variables.variables[0].element; |
| TopLevelVariableDeclaration use = |
| partUnit.declarations[0] as TopLevelVariableDeclaration; |
| Element useElement = (use.variables.variables[0].initializer |
| as SimpleIdentifier).staticElement; |
| expect((useElement as PropertyAccessorElement).variable, |
| same(declarationElement)); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [partSource]); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertEvent(changedSources: [partSource]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| Future test_applyChanges_change_range() { |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| expect(_context.sourcesNeedingProcessing.isEmpty, isTrue); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet1 = new ChangeSet(); |
| changeSet1.addedSource(source); |
| _context.applyChanges(changeSet1); |
| expect(_context.sourcesNeedingProcessing.contains(source), isTrue); |
| Source source2 = |
| new FileBasedSource(FileUtilities2.createFile("/test2.dart")); |
| ChangeSet changeSet2 = new ChangeSet(); |
| changeSet2.addedSource(source2); |
| changeSet2.changedRange(source, 'library test;', 0, 0, 13); |
| _context.applyChanges(changeSet2); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(wereSourcesAdded: true, changedSources: [source]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| void test_applyChanges_empty() { |
| _context.applyChanges(new ChangeSet()); |
| expect(_context.performAnalysisTask().changeNotices, isNull); |
| } |
| |
| void test_applyChanges_overriddenSource() { |
| // Note: addSource adds the source to the contentCache. |
| Source source = _addSource("/test.dart", "library test;"); |
| _context.computeErrors(source); |
| while (!_context.sourcesNeedingProcessing.isEmpty) { |
| _context.performAnalysisTask(); |
| } |
| // Adding the source as a changedSource should have no effect since |
| // it is already overridden in the content cache. |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.changedSource(source); |
| _context.applyChanges(changeSet); |
| expect(_context.sourcesNeedingProcessing, hasLength(0)); |
| } |
| |
| Future test_applyChanges_remove() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| _sourceFactory = _context.sourceFactory; |
| String libAContents = r''' |
| library libA; |
| import 'libB.dart';'''; |
| Source libA = _addSource("/libA.dart", libAContents); |
| String libBContents = "library libB;"; |
| Source libB = _addSource("/libB.dart", libBContents); |
| LibraryElement libAElement = _context.computeLibraryElement(libA); |
| List<LibraryElement> importedLibraries = libAElement.importedLibraries; |
| expect(importedLibraries, hasLength(2)); |
| _context.computeErrors(libA); |
| _context.computeErrors(libB); |
| expect(_context.sourcesNeedingProcessing, hasLength(0)); |
| _context.setContents(libB, null); |
| _removeSource(libB); |
| List<Source> sources = _context.sourcesNeedingProcessing; |
| expect(sources, hasLength(1)); |
| expect(sources[0], same(libA)); |
| libAElement = _context.computeLibraryElement(libA); |
| importedLibraries = libAElement.importedLibraries; |
| expect(importedLibraries, hasLength(1)); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [libA]); |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [libB]); |
| listener.assertEvent(changedSources: [libB]); |
| listener.assertEvent(wereSourcesRemovedOrDeleted: true); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| /** |
| * IDEA uses the following scenario: |
| * 1. Add overlay. |
| * 2. Change overlay. |
| * 3. If the contents of the document buffer is the same as the contents |
| * of the file, remove overlay. |
| * So, we need to try to use incremental resolution for removing overlays too. |
| */ |
| void test_applyChanges_remove_incremental() { |
| MemoryResourceProvider resourceProvider = new MemoryResourceProvider(); |
| Source source = resourceProvider |
| .newFile( |
| '/test.dart', |
| r''' |
| main() { |
| print(1); |
| } |
| ''') |
| .createSource(); |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _context.analysisOptions = new AnalysisOptionsImpl()..incremental = true; |
| _context.applyChanges(new ChangeSet()..addedSource(source)); |
| // remember compilation unit |
| _analyzeAll_assertFinished(); |
| CompilationUnit unit = _context.getResolvedCompilationUnit2(source, source); |
| // add overlay |
| _context.setContents( |
| source, |
| r''' |
| main() { |
| print(12); |
| } |
| '''); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedCompilationUnit2(source, source), unit); |
| // remove overlay |
| _context.setContents(source, null); |
| _context.validateCacheConsistency(); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedCompilationUnit2(source, source), unit); |
| } |
| |
| Future test_applyChanges_removeContainer() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| _sourceFactory = _context.sourceFactory; |
| String libAContents = r''' |
| library libA; |
| import 'libB.dart';'''; |
| Source libA = _addSource("/libA.dart", libAContents); |
| String libBContents = "library libB;"; |
| Source libB = _addSource("/libB.dart", libBContents); |
| _context.computeLibraryElement(libA); |
| _context.computeErrors(libA); |
| _context.computeErrors(libB); |
| expect(_context.sourcesNeedingProcessing, hasLength(0)); |
| ChangeSet changeSet = new ChangeSet(); |
| SourceContainer removedContainer = |
| new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB); |
| changeSet.removedContainer(removedContainer); |
| _context.applyChanges(changeSet); |
| List<Source> sources = _context.sourcesNeedingProcessing; |
| expect(sources, hasLength(1)); |
| expect(sources[0], same(libA)); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [libA]); |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [libB]); |
| listener.assertEvent(wereSourcesRemovedOrDeleted: true); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| void test_computeDocumentationComment_block() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| String comment = "/** Comment */"; |
| Source source = _addSource( |
| "/test.dart", |
| """ |
| $comment |
| class A {}"""); |
| LibraryElement libraryElement = _context.computeLibraryElement(source); |
| expect(libraryElement, isNotNull); |
| ClassElement classElement = libraryElement.definingCompilationUnit.types[0]; |
| expect(libraryElement, isNotNull); |
| expect(_context.computeDocumentationComment(classElement), comment); |
| } |
| |
| void test_computeDocumentationComment_none() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.dart", "class A {}"); |
| LibraryElement libraryElement = _context.computeLibraryElement(source); |
| expect(libraryElement, isNotNull); |
| ClassElement classElement = libraryElement.definingCompilationUnit.types[0]; |
| expect(libraryElement, isNotNull); |
| expect(_context.computeDocumentationComment(classElement), isNull); |
| } |
| |
| void test_computeDocumentationComment_null() { |
| expect(_context.computeDocumentationComment(null), isNull); |
| } |
| |
| void test_computeDocumentationComment_singleLine_multiple_EOL_n() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| String comment = "/// line 1\n/// line 2\n/// line 3\n"; |
| Source source = _addSource("/test.dart", "${comment}class A {}"); |
| LibraryElement libraryElement = _context.computeLibraryElement(source); |
| expect(libraryElement, isNotNull); |
| ClassElement classElement = libraryElement.definingCompilationUnit.types[0]; |
| expect(libraryElement, isNotNull); |
| String actual = _context.computeDocumentationComment(classElement); |
| expect(actual, "/// line 1\n/// line 2\n/// line 3"); |
| } |
| |
| void test_computeDocumentationComment_singleLine_multiple_EOL_rn() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| String comment = "/// line 1\r\n/// line 2\r\n/// line 3\r\n"; |
| Source source = _addSource("/test.dart", "${comment}class A {}"); |
| LibraryElement libraryElement = _context.computeLibraryElement(source); |
| expect(libraryElement, isNotNull); |
| ClassElement classElement = libraryElement.definingCompilationUnit.types[0]; |
| expect(libraryElement, isNotNull); |
| String actual = _context.computeDocumentationComment(classElement); |
| expect(actual, "/// line 1\n/// line 2\n/// line 3"); |
| } |
| |
| void test_computeErrors_dart_none() { |
| Source source = _addSource("/lib.dart", "library lib;"); |
| List<AnalysisError> errors = _context.computeErrors(source); |
| expect(errors, hasLength(0)); |
| } |
| |
| void test_computeErrors_dart_part() { |
| Source librarySource = |
| _addSource("/lib.dart", "library lib; part 'part.dart';"); |
| Source partSource = _addSource("/part.dart", "part of 'lib';"); |
| _context.parseCompilationUnit(librarySource); |
| List<AnalysisError> errors = _context.computeErrors(partSource); |
| expect(errors, isNotNull); |
| expect(errors.length > 0, isTrue); |
| } |
| |
| void test_computeErrors_dart_some() { |
| Source source = _addSource("/lib.dart", "library 'lib';"); |
| List<AnalysisError> errors = _context.computeErrors(source); |
| expect(errors, isNotNull); |
| expect(errors.length > 0, isTrue); |
| } |
| |
| void test_computeErrors_html_none() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| List<AnalysisError> errors = _context.computeErrors(source); |
| expect(errors, hasLength(0)); |
| } |
| |
| void test_computeExportedLibraries_none() { |
| Source source = _addSource("/test.dart", "library test;"); |
| expect(_context.computeExportedLibraries(source), hasLength(0)); |
| } |
| |
| void test_computeExportedLibraries_some() { |
| // addSource("/lib1.dart", "library lib1;"); |
| // addSource("/lib2.dart", "library lib2;"); |
| Source source = _addSource( |
| "/test.dart", "library test; export 'lib1.dart'; export 'lib2.dart';"); |
| expect(_context.computeExportedLibraries(source), hasLength(2)); |
| } |
| |
| void test_computeHtmlElement_nonHtml() { |
| Source source = _addSource("/test.dart", "library test;"); |
| expect(_context.computeHtmlElement(source), isNull); |
| } |
| |
| void test_computeHtmlElement_valid() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| HtmlElement element = _context.computeHtmlElement(source); |
| expect(element, isNotNull); |
| expect(_context.computeHtmlElement(source), same(element)); |
| } |
| |
| void test_computeImportedLibraries_none() { |
| Source source = _addSource("/test.dart", "library test;"); |
| expect(_context.computeImportedLibraries(source), hasLength(0)); |
| } |
| |
| void test_computeImportedLibraries_some() { |
| // addSource("/lib1.dart", "library lib1;"); |
| // addSource("/lib2.dart", "library lib2;"); |
| Source source = _addSource( |
| "/test.dart", "library test; import 'lib1.dart'; import 'lib2.dart';"); |
| expect(_context.computeImportedLibraries(source), hasLength(2)); |
| } |
| |
| void test_computeKindOf_html() { |
| Source source = _addSource("/test.html", ""); |
| expect(_context.computeKindOf(source), same(SourceKind.HTML)); |
| } |
| |
| void test_computeKindOf_library() { |
| Source source = _addSource("/test.dart", "library lib;"); |
| expect(_context.computeKindOf(source), same(SourceKind.LIBRARY)); |
| } |
| |
| void test_computeKindOf_libraryAndPart() { |
| Source source = _addSource("/test.dart", "library lib; part of lib;"); |
| expect(_context.computeKindOf(source), same(SourceKind.LIBRARY)); |
| } |
| |
| void test_computeKindOf_part() { |
| Source source = _addSource("/test.dart", "part of lib;"); |
| expect(_context.computeKindOf(source), same(SourceKind.PART)); |
| } |
| |
| void test_computeLibraryElement() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.dart", "library lib;"); |
| LibraryElement element = _context.computeLibraryElement(source); |
| expect(element, isNotNull); |
| } |
| |
| void test_computeLineInfo_dart() { |
| Source source = _addSource( |
| "/test.dart", |
| r''' |
| library lib; |
| |
| main() {}'''); |
| LineInfo info = _context.computeLineInfo(source); |
| expect(info, isNotNull); |
| } |
| |
| void test_computeLineInfo_html() { |
| Source source = _addSource( |
| "/test.html", |
| r''' |
| <html> |
| <body> |
| <h1>A</h1> |
| </body> |
| </html>'''); |
| LineInfo info = _context.computeLineInfo(source); |
| expect(info, isNotNull); |
| } |
| |
| void test_computeResolvableCompilationUnit_dart_exception() { |
| TestSource source = _addSourceWithException("/test.dart"); |
| try { |
| _context.computeResolvableCompilationUnit(source); |
| fail("Expected AnalysisException"); |
| } on AnalysisException { |
| // Expected |
| } |
| } |
| |
| void test_computeResolvableCompilationUnit_html_exception() { |
| Source source = _addSource("/lib.html", "<html></html>"); |
| try { |
| _context.computeResolvableCompilationUnit(source); |
| fail("Expected AnalysisException"); |
| } on AnalysisException { |
| // Expected |
| } |
| } |
| |
| void test_computeResolvableCompilationUnit_valid() { |
| Source source = _addSource("/lib.dart", "library lib;"); |
| CompilationUnit parsedUnit = _context.parseCompilationUnit(source); |
| expect(parsedUnit, isNotNull); |
| CompilationUnit resolvedUnit = |
| _context.computeResolvableCompilationUnit(source); |
| expect(resolvedUnit, isNotNull); |
| expect(resolvedUnit, same(parsedUnit)); |
| } |
| |
| Future test_computeResolvedCompilationUnitAsync() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| // Complete all pending analysis tasks and flush the AST so that it won't |
| // be available immediately. |
| _performPendingAnalysisTasks(); |
| DartEntry dartEntry = _context.getReadableSourceEntryOrNull(source); |
| dartEntry.flushAstStructures(); |
| bool completed = false; |
| _context |
| .computeResolvedCompilationUnitAsync(source, source) |
| .then((CompilationUnit unit) { |
| expect(unit, isNotNull); |
| completed = true; |
| }); |
| return pumpEventQueue().then((_) { |
| expect(completed, isFalse); |
| _performPendingAnalysisTasks(); |
| }).then((_) => pumpEventQueue()).then((_) { |
| expect(completed, isTrue); |
| }); |
| } |
| |
| Future test_computeResolvedCompilationUnitAsync_afterDispose() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| // Complete all pending analysis tasks and flush the AST so that it won't |
| // be available immediately. |
| _performPendingAnalysisTasks(); |
| DartEntry dartEntry = _context.getReadableSourceEntryOrNull(source); |
| dartEntry.flushAstStructures(); |
| // Dispose of the context. |
| _context.dispose(); |
| // Any attempt to start an asynchronous computation should return a future |
| // which completes with error. |
| CancelableFuture<CompilationUnit> future = |
| _context.computeResolvedCompilationUnitAsync(source, source); |
| bool completed = false; |
| future.then((CompilationUnit unit) { |
| fail('Future should have completed with error'); |
| }, onError: (error) { |
| expect(error, new isInstanceOf<AnalysisNotScheduledError>()); |
| completed = true; |
| }); |
| return pumpEventQueue().then((_) { |
| expect(completed, isTrue); |
| }); |
| } |
| |
| Future test_computeResolvedCompilationUnitAsync_cancel() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| // Complete all pending analysis tasks and flush the AST so that it won't |
| // be available immediately. |
| _performPendingAnalysisTasks(); |
| DartEntry dartEntry = _context.getReadableSourceEntryOrNull(source); |
| dartEntry.flushAstStructures(); |
| CancelableFuture<CompilationUnit> future = |
| _context.computeResolvedCompilationUnitAsync(source, source); |
| bool completed = false; |
| future.then((CompilationUnit unit) { |
| fail('Future should have been canceled'); |
| }, onError: (error) { |
| expect(error, new isInstanceOf<FutureCanceledError>()); |
| completed = true; |
| }); |
| expect(completed, isFalse); |
| expect(_context.pendingFutureSources_forTesting, isNotEmpty); |
| future.cancel(); |
| expect(_context.pendingFutureSources_forTesting, isEmpty); |
| return pumpEventQueue().then((_) { |
| expect(completed, isTrue); |
| expect(_context.pendingFutureSources_forTesting, isEmpty); |
| }); |
| } |
| |
| Future test_computeResolvedCompilationUnitAsync_dispose() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| // Complete all pending analysis tasks and flush the AST so that it won't |
| // be available immediately. |
| _performPendingAnalysisTasks(); |
| DartEntry dartEntry = _context.getReadableSourceEntryOrNull(source); |
| dartEntry.flushAstStructures(); |
| CancelableFuture<CompilationUnit> future = |
| _context.computeResolvedCompilationUnitAsync(source, source); |
| bool completed = false; |
| future.then((CompilationUnit unit) { |
| fail('Future should have completed with error'); |
| }, onError: (error) { |
| expect(error, new isInstanceOf<AnalysisNotScheduledError>()); |
| completed = true; |
| }); |
| expect(completed, isFalse); |
| expect(_context.pendingFutureSources_forTesting, isNotEmpty); |
| // Disposing of the context should cause all pending futures to complete |
| // with AnalysisNotScheduled, so that no clients are left hanging. |
| _context.dispose(); |
| expect(_context.pendingFutureSources_forTesting, isEmpty); |
| return pumpEventQueue().then((_) { |
| expect(completed, isTrue); |
| expect(_context.pendingFutureSources_forTesting, isEmpty); |
| }); |
| } |
| |
| Future test_computeResolvedCompilationUnitAsync_unrelatedLibrary() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source librarySource = _addSource("/lib.dart", "library lib;"); |
| Source partSource = _addSource("/part.dart", "part of foo;"); |
| bool completed = false; |
| _context |
| .computeResolvedCompilationUnitAsync(partSource, librarySource) |
| .then((_) { |
| fail('Expected resolution to fail'); |
| }, onError: (e) { |
| expect(e, new isInstanceOf<AnalysisNotScheduledError>()); |
| completed = true; |
| }); |
| return pumpEventQueue().then((_) { |
| expect(completed, isFalse); |
| _performPendingAnalysisTasks(); |
| }).then((_) => pumpEventQueue()).then((_) { |
| expect(completed, isTrue); |
| }); |
| } |
| |
| void test_dispose() { |
| expect(_context.isDisposed, isFalse); |
| _context.dispose(); |
| expect(_context.isDisposed, isTrue); |
| } |
| |
| void test_exists_false() { |
| TestSource source = new TestSource(); |
| source.exists2 = false; |
| expect(_context.exists(source), isFalse); |
| } |
| |
| void test_exists_null() { |
| expect(_context.exists(null), isFalse); |
| } |
| |
| void test_exists_overridden() { |
| Source source = new TestSource(); |
| _context.setContents(source, ""); |
| expect(_context.exists(source), isTrue); |
| } |
| |
| void test_exists_true() { |
| expect(_context.exists(new AnalysisContextImplTest_Source_exists_true()), |
| isTrue); |
| } |
| |
| void test_getAnalysisOptions() { |
| expect(_context.analysisOptions, isNotNull); |
| } |
| |
| void test_getContents_fromSource() { |
| String content = "library lib;"; |
| TimestampedData<String> contents = |
| _context.getContents(new TestSource('/test.dart', content)); |
| expect(contents.data.toString(), content); |
| } |
| |
| void test_getContents_overridden() { |
| String content = "library lib;"; |
| Source source = new TestSource(); |
| _context.setContents(source, content); |
| TimestampedData<String> contents = _context.getContents(source); |
| expect(contents.data.toString(), content); |
| } |
| |
| void test_getContents_unoverridden() { |
| String content = "library lib;"; |
| Source source = new TestSource('/test.dart', content); |
| _context.setContents(source, "part of lib;"); |
| _context.setContents(source, null); |
| TimestampedData<String> contents = _context.getContents(source); |
| expect(contents.data.toString(), content); |
| } |
| |
| void test_getDeclaredVariables() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| expect(_context.declaredVariables, isNotNull); |
| } |
| |
| void test_getElement() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| LibraryElement core = |
| _context.computeLibraryElement(_sourceFactory.forUri("dart:core")); |
| expect(core, isNotNull); |
| ClassElement classObject = |
| _findClass(core.definingCompilationUnit, "Object"); |
| expect(classObject, isNotNull); |
| ElementLocation location = classObject.location; |
| Element element = _context.getElement(location); |
| expect(element, same(classObject)); |
| } |
| |
| void test_getElement_constructor_named() { |
| Source source = _addSource( |
| "/lib.dart", |
| r''' |
| class A { |
| A.named() {} |
| }'''); |
| _analyzeAll_assertFinished(); |
| LibraryElement library = _context.computeLibraryElement(source); |
| ClassElement classA = _findClass(library.definingCompilationUnit, "A"); |
| ConstructorElement constructor = classA.constructors[0]; |
| ElementLocation location = constructor.location; |
| Element element = _context.getElement(location); |
| expect(element, same(constructor)); |
| } |
| |
| void test_getElement_constructor_unnamed() { |
| Source source = _addSource( |
| "/lib.dart", |
| r''' |
| class A { |
| A() {} |
| }'''); |
| _analyzeAll_assertFinished(); |
| LibraryElement library = _context.computeLibraryElement(source); |
| ClassElement classA = _findClass(library.definingCompilationUnit, "A"); |
| ConstructorElement constructor = classA.constructors[0]; |
| ElementLocation location = constructor.location; |
| Element element = _context.getElement(location); |
| expect(element, same(constructor)); |
| } |
| |
| void test_getElement_enum() { |
| Source source = _addSource('/test.dart', 'enum MyEnum {A, B, C}'); |
| _analyzeAll_assertFinished(); |
| LibraryElement library = _context.computeLibraryElement(source); |
| ClassElement myEnum = library.definingCompilationUnit.getEnum('MyEnum'); |
| ElementLocation location = myEnum.location; |
| Element element = _context.getElement(location); |
| expect(element, same(myEnum)); |
| } |
| |
| void test_getErrors_dart_none() { |
| Source source = _addSource("/lib.dart", "library lib;"); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| _context.computeErrors(source); |
| errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| } |
| |
| void test_getErrors_dart_some() { |
| Source source = _addSource("/lib.dart", "library 'lib';"); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| _context.computeErrors(source); |
| errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(1)); |
| } |
| |
| void test_getErrors_html_none() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| _context.computeErrors(source); |
| errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| } |
| |
| void test_getErrors_html_some() { |
| Source source = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.dart'/> |
| </head></html>'''); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(0)); |
| _context.computeErrors(source); |
| errors = _context.getErrors(source).errors; |
| expect(errors, hasLength(1)); |
| } |
| |
| void test_getHtmlElement_dart() { |
| Source source = _addSource("/test.dart", ""); |
| expect(_context.getHtmlElement(source), isNull); |
| expect(_context.computeHtmlElement(source), isNull); |
| expect(_context.getHtmlElement(source), isNull); |
| } |
| |
| void test_getHtmlElement_html() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| HtmlElement element = _context.getHtmlElement(source); |
| expect(element, isNull); |
| _context.computeHtmlElement(source); |
| element = _context.getHtmlElement(source); |
| expect(element, isNotNull); |
| } |
| |
| void test_getHtmlFilesReferencing_html() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source htmlSource = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.dart'/> |
| <script type='application/dart' src='test.js'/> |
| </head></html>'''); |
| Source librarySource = _addSource("/test.dart", "library lib;"); |
| Source secondHtmlSource = _addSource("/test.html", "<html></html>"); |
| _context.computeLibraryElement(librarySource); |
| List<Source> result = _context.getHtmlFilesReferencing(secondHtmlSource); |
| expect(result, hasLength(0)); |
| _context.parseHtmlUnit(htmlSource); |
| result = _context.getHtmlFilesReferencing(secondHtmlSource); |
| expect(result, hasLength(0)); |
| } |
| |
| void test_getHtmlFilesReferencing_library() { |
| Source htmlSource = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.dart'/> |
| <script type='application/dart' src='test.js'/> |
| </head></html>'''); |
| Source librarySource = _addSource("/test.dart", "library lib;"); |
| List<Source> result = _context.getHtmlFilesReferencing(librarySource); |
| expect(result, hasLength(0)); |
| _context.parseHtmlUnit(htmlSource); |
| result = _context.getHtmlFilesReferencing(librarySource); |
| expect(result, hasLength(1)); |
| expect(result[0], htmlSource); |
| } |
| |
| void test_getHtmlFilesReferencing_part() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source htmlSource = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.dart'/> |
| <script type='application/dart' src='test.js'/> |
| </head></html>'''); |
| Source librarySource = |
| _addSource("/test.dart", "library lib; part 'part.dart';"); |
| Source partSource = _addSource("/part.dart", "part of lib;"); |
| _context.computeLibraryElement(librarySource); |
| List<Source> result = _context.getHtmlFilesReferencing(partSource); |
| expect(result, hasLength(0)); |
| _context.parseHtmlUnit(htmlSource); |
| result = _context.getHtmlFilesReferencing(partSource); |
| expect(result, hasLength(1)); |
| expect(result[0], htmlSource); |
| } |
| |
| void test_getHtmlSources() { |
| List<Source> sources = _context.htmlSources; |
| expect(sources, hasLength(0)); |
| Source source = _addSource("/test.html", ""); |
| _context.computeKindOf(source); |
| sources = _context.htmlSources; |
| expect(sources, hasLength(1)); |
| expect(sources[0], source); |
| } |
| |
| void test_getKindOf_html() { |
| Source source = _addSource("/test.html", ""); |
| expect(_context.getKindOf(source), same(SourceKind.HTML)); |
| } |
| |
| void test_getKindOf_library() { |
| Source source = _addSource("/test.dart", "library lib;"); |
| expect(_context.getKindOf(source), same(SourceKind.UNKNOWN)); |
| _context.computeKindOf(source); |
| expect(_context.getKindOf(source), same(SourceKind.LIBRARY)); |
| } |
| |
| void test_getKindOf_part() { |
| Source source = _addSource("/test.dart", "part of lib;"); |
| expect(_context.getKindOf(source), same(SourceKind.UNKNOWN)); |
| _context.computeKindOf(source); |
| expect(_context.getKindOf(source), same(SourceKind.PART)); |
| } |
| |
| void test_getKindOf_unknown() { |
| Source source = _addSource("/test.css", ""); |
| expect(_context.getKindOf(source), same(SourceKind.UNKNOWN)); |
| } |
| |
| void test_getLaunchableClientLibrarySources() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| List<Source> sources = _context.launchableClientLibrarySources; |
| expect(sources, hasLength(0)); |
| Source source = _addSource( |
| "/test.dart", |
| r''' |
| import 'dart:html'; |
| main() {}'''); |
| _context.computeLibraryElement(source); |
| sources = _context.launchableClientLibrarySources; |
| expect(sources, hasLength(1)); |
| } |
| |
| void test_getLaunchableServerLibrarySources() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| List<Source> sources = _context.launchableServerLibrarySources; |
| expect(sources, hasLength(0)); |
| Source source = _addSource("/test.dart", "main() {}"); |
| _context.computeLibraryElement(source); |
| sources = _context.launchableServerLibrarySources; |
| expect(sources, hasLength(1)); |
| } |
| |
| void test_getLibrariesContaining() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source librarySource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| part 'part.dart';'''); |
| Source partSource = _addSource("/part.dart", "part of lib;"); |
| _context.computeLibraryElement(librarySource); |
| List<Source> result = _context.getLibrariesContaining(librarySource); |
| expect(result, hasLength(1)); |
| expect(result[0], librarySource); |
| result = _context.getLibrariesContaining(partSource); |
| expect(result, hasLength(1)); |
| expect(result[0], librarySource); |
| } |
| |
| void test_getLibrariesDependingOn() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source libASource = _addSource("/libA.dart", "library libA;"); |
| _addSource("/libB.dart", "library libB;"); |
| Source lib1Source = _addSource( |
| "/lib1.dart", |
| r''' |
| library lib1; |
| import 'libA.dart'; |
| export 'libB.dart';'''); |
| Source lib2Source = _addSource( |
| "/lib2.dart", |
| r''' |
| library lib2; |
| import 'libB.dart'; |
| export 'libA.dart';'''); |
| _context.computeLibraryElement(lib1Source); |
| _context.computeLibraryElement(lib2Source); |
| List<Source> result = _context.getLibrariesDependingOn(libASource); |
| expect(result, unorderedEquals([lib1Source, lib2Source])); |
| } |
| |
| void test_getLibrariesReferencedFromHtml() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source htmlSource = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.dart'/> |
| <script type='application/dart' src='test.js'/> |
| </head></html>'''); |
| Source librarySource = _addSource("/test.dart", "library lib;"); |
| _context.computeLibraryElement(librarySource); |
| _context.parseHtmlUnit(htmlSource); |
| List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource); |
| expect(result, hasLength(1)); |
| expect(result[0], librarySource); |
| } |
| |
| void test_getLibrariesReferencedFromHtml_no() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source htmlSource = _addSource( |
| "/test.html", |
| r''' |
| <html><head> |
| <script type='application/dart' src='test.js'/> |
| </head></html>'''); |
| _addSource("/test.dart", "library lib;"); |
| _context.parseHtmlUnit(htmlSource); |
| List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource); |
| expect(result, hasLength(0)); |
| } |
| |
| void test_getLibraryElement() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.dart", "library lib;"); |
| LibraryElement element = _context.getLibraryElement(source); |
| expect(element, isNull); |
| _context.computeLibraryElement(source); |
| element = _context.getLibraryElement(source); |
| expect(element, isNotNull); |
| } |
| |
| void test_getLibrarySources() { |
| List<Source> sources = _context.librarySources; |
| int originalLength = sources.length; |
| Source source = _addSource("/test.dart", "library lib;"); |
| _context.computeKindOf(source); |
| sources = _context.librarySources; |
| expect(sources, hasLength(originalLength + 1)); |
| for (Source returnedSource in sources) { |
| if (returnedSource == source) { |
| return; |
| } |
| } |
| fail("The added source was not in the list of library sources"); |
| } |
| |
| void test_getLineInfo() { |
| Source source = _addSource( |
| "/test.dart", |
| r''' |
| library lib; |
| |
| main() {}'''); |
| LineInfo info = _context.getLineInfo(source); |
| expect(info, isNull); |
| _context.parseCompilationUnit(source); |
| info = _context.getLineInfo(source); |
| expect(info, isNotNull); |
| } |
| |
| void test_getModificationStamp_fromSource() { |
| int stamp = 42; |
| expect( |
| _context.getModificationStamp( |
| new AnalysisContextImplTest_Source_getModificationStamp_fromSource( |
| stamp)), |
| stamp); |
| } |
| |
| void test_getModificationStamp_overridden() { |
| int stamp = 42; |
| Source source = |
| new AnalysisContextImplTest_Source_getModificationStamp_overridden( |
| stamp); |
| _context.setContents(source, ""); |
| expect(stamp != _context.getModificationStamp(source), isTrue); |
| } |
| |
| void test_getPublicNamespace_element() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.dart", "class A {}"); |
| LibraryElement library = _context.computeLibraryElement(source); |
| Namespace namespace = _context.getPublicNamespace(library); |
| expect(namespace, isNotNull); |
| EngineTestCase.assertInstanceOf( |
| (obj) => obj is ClassElement, ClassElement, namespace.get("A")); |
| } |
| |
| void test_getResolvedCompilationUnit_library() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library libb;"); |
| LibraryElement library = _context.computeLibraryElement(source); |
| expect(_context.getResolvedCompilationUnit(source, library), isNotNull); |
| _context.setContents(source, "library lib;"); |
| expect(_context.getResolvedCompilationUnit(source, library), isNull); |
| } |
| |
| void test_getResolvedCompilationUnit_library_null() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| expect(_context.getResolvedCompilationUnit(source, null), isNull); |
| } |
| |
| void test_getResolvedCompilationUnit_source_dart() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| expect(_context.getResolvedCompilationUnit2(source, source), isNull); |
| _context.resolveCompilationUnit2(source, source); |
| expect(_context.getResolvedCompilationUnit2(source, source), isNotNull); |
| } |
| |
| void test_getResolvedCompilationUnit_source_html() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.html", "<html></html>"); |
| expect(_context.getResolvedCompilationUnit2(source, source), isNull); |
| expect(_context.resolveCompilationUnit2(source, source), isNull); |
| expect(_context.getResolvedCompilationUnit2(source, source), isNull); |
| } |
| |
| void test_getResolvedHtmlUnit() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/test.html", "<html></html>"); |
| expect(_context.getResolvedHtmlUnit(source), isNull); |
| _context.resolveHtmlUnit(source); |
| expect(_context.getResolvedHtmlUnit(source), isNotNull); |
| } |
| |
| void test_getSourceFactory() { |
| expect(_context.sourceFactory, same(_sourceFactory)); |
| } |
| |
| void test_getSourcesWithFullName() { |
| String filePath = '/foo/lib/file.dart'; |
| List<Source> expected = <Source>[]; |
| ChangeSet changeSet = new ChangeSet(); |
| |
| TestSourceWithUri source1 = |
| new TestSourceWithUri(filePath, Uri.parse('file://$filePath')); |
| expected.add(source1); |
| changeSet.addedSource(source1); |
| |
| TestSourceWithUri source2 = |
| new TestSourceWithUri(filePath, Uri.parse('package:foo/file.dart')); |
| expected.add(source2); |
| changeSet.addedSource(source2); |
| |
| _context.applyChanges(changeSet); |
| expect( |
| _context.getSourcesWithFullName(filePath), unorderedEquals(expected)); |
| } |
| |
| void test_getStatistics() { |
| AnalysisContextStatistics statistics = _context.statistics; |
| expect(statistics, isNotNull); |
| // The following lines are fragile. |
| // The values depend on the number of libraries in the SDK. |
| // assertLength(0, statistics.getCacheRows()); |
| // assertLength(0, statistics.getExceptions()); |
| // assertLength(0, statistics.getSources()); |
| } |
| |
| Future test_implicitAnalysisEvents_added() async { |
| AnalyzedSourcesListener listener = new AnalyzedSourcesListener(); |
| _context.implicitAnalysisEvents.listen(listener.onData); |
| // |
| // Create a file that references an file that is not explicitly being |
| // analyzed and fully analyze it. Ensure that the listener is told about |
| // the implicitly analyzed file. |
| // |
| Source sourceA = _addSource('/a.dart', "library a; import 'b.dart';"); |
| Source sourceB = _createSource('/b.dart', "library b;"); |
| _context.computeErrors(sourceA); |
| await pumpEventQueue(); |
| listener.expectAnalyzed(sourceB); |
| } |
| |
| void test_isClientLibrary_dart() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource( |
| "/test.dart", |
| r''' |
| import 'dart:html'; |
| |
| main() {}'''); |
| expect(_context.isClientLibrary(source), isFalse); |
| expect(_context.isServerLibrary(source), isFalse); |
| _context.computeLibraryElement(source); |
| expect(_context.isClientLibrary(source), isTrue); |
| expect(_context.isServerLibrary(source), isFalse); |
| } |
| |
| void test_isClientLibrary_html() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| expect(_context.isClientLibrary(source), isFalse); |
| } |
| |
| void test_isServerLibrary_dart() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource( |
| "/test.dart", |
| r''' |
| library lib; |
| |
| main() {}'''); |
| expect(_context.isClientLibrary(source), isFalse); |
| expect(_context.isServerLibrary(source), isFalse); |
| _context.computeLibraryElement(source); |
| expect(_context.isClientLibrary(source), isFalse); |
| expect(_context.isServerLibrary(source), isTrue); |
| } |
| |
| void test_isServerLibrary_html() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| expect(_context.isServerLibrary(source), isFalse); |
| } |
| |
| void test_parseCompilationUnit_errors() { |
| Source source = _addSource("/lib.dart", "library {"); |
| CompilationUnit compilationUnit = _context.parseCompilationUnit(source); |
| expect(compilationUnit, isNotNull); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| expect(errors, isNotNull); |
| expect(errors.length > 0, isTrue); |
| } |
| |
| void test_parseCompilationUnit_exception() { |
| Source source = _addSourceWithException("/test.dart"); |
| try { |
| _context.parseCompilationUnit(source); |
| fail("Expected AnalysisException"); |
| } on AnalysisException { |
| // Expected |
| } |
| } |
| |
| void test_parseCompilationUnit_html() { |
| Source source = _addSource("/test.html", "<html></html>"); |
| expect(_context.parseCompilationUnit(source), isNull); |
| } |
| |
| void test_parseCompilationUnit_noErrors() { |
| Source source = _addSource("/lib.dart", "library lib;"); |
| CompilationUnit compilationUnit = _context.parseCompilationUnit(source); |
| expect(compilationUnit, isNotNull); |
| expect(_context.getErrors(source).errors, hasLength(0)); |
| } |
| |
| void test_parseCompilationUnit_nonExistentSource() { |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| try { |
| _context.parseCompilationUnit(source); |
| fail("Expected AnalysisException because file does not exist"); |
| } on AnalysisException { |
| // Expected result |
| } |
| } |
| |
| void test_parseHtmlUnit_noErrors() { |
| Source source = _addSource("/lib.html", "<html></html>"); |
| ht.HtmlUnit unit = _context.parseHtmlUnit(source); |
| expect(unit, isNotNull); |
| } |
| |
| void test_parseHtmlUnit_resolveDirectives() { |
| Source libSource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| class ClassA {}'''); |
| Source source = _addSource( |
| "/lib.html", |
| r''' |
| <html> |
| <head> |
| <script type='application/dart'> |
| import 'lib.dart'; |
| ClassA v = null; |
| </script> |
| </head> |
| <body> |
| </body> |
| </html>'''); |
| ht.HtmlUnit unit = _context.parseHtmlUnit(source); |
| // import directive should be resolved |
| ht.XmlTagNode htmlNode = unit.tagNodes[0]; |
| ht.XmlTagNode headNode = htmlNode.tagNodes[0]; |
| ht.HtmlScriptTagNode scriptNode = headNode.tagNodes[0]; |
| CompilationUnit script = scriptNode.script; |
| ImportDirective importNode = script.directives[0] as ImportDirective; |
| expect(importNode.uriContent, isNotNull); |
| expect(importNode.source, libSource); |
| } |
| |
| void test_performAnalysisTask_addPart() { |
| Source libSource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| part 'part.dart';'''); |
| // run all tasks without part |
| _analyzeAll_assertFinished(); |
| // add part and run all tasks |
| Source partSource = _addSource( |
| "/part.dart", |
| r''' |
| part of lib; |
| '''); |
| _analyzeAll_assertFinished(); |
| // "libSource" should be here |
| List<Source> librariesWithPart = |
| _context.getLibrariesContaining(partSource); |
| expect(librariesWithPart, unorderedEquals([libSource])); |
| } |
| |
| void test_performAnalysisTask_changeLibraryContents() { |
| Source libSource = |
| _addSource("/test.dart", "library lib; part 'test-part.dart';"); |
| Source partSource = _addSource("/test-part.dart", "part of lib;"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 1"); |
| // update and analyze #1 |
| _context.setContents(libSource, "library lib;"); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 2"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part resolved 2"); |
| // update and analyze #2 |
| _context.setContents(libSource, "library lib; part 'test-part.dart';"); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 3"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 3"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 2"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 3"); |
| } |
| |
| void test_performAnalysisTask_changeLibraryThenPartContents() { |
| Source libSource = |
| _addSource("/test.dart", "library lib; part 'test-part.dart';"); |
| Source partSource = _addSource("/test-part.dart", "part of lib;"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 1"); |
| // update and analyze #1 |
| _context.setContents(libSource, "library lib;"); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 2"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part resolved 2"); |
| // update and analyze #2 |
| _context.setContents(partSource, "part of lib; // 1"); |
| // Assert that changing the part's content does not effect the library |
| // now that it is no longer part of that library |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library changed 3"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 3"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 3"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part resolved 3"); |
| } |
| |
| void test_performAnalysisTask_changePartContents_makeItAPart() { |
| Source libSource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| part 'part.dart'; |
| void f(x) {}'''); |
| Source partSource = _addSource("/part.dart", "void g() { f(null); }"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 1"); |
| // update and analyze |
| _context.setContents( |
| partSource, |
| r''' |
| part of lib; |
| void g() { f(null); }'''); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 2"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 2"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 2"); |
| expect(_context.getErrors(libSource).errors, hasLength(0)); |
| expect(_context.getErrors(partSource).errors, hasLength(0)); |
| } |
| |
| /** |
| * https://code.google.com/p/dart/issues/detail?id=12424 |
| */ |
| void test_performAnalysisTask_changePartContents_makeItNotPart() { |
| Source libSource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| part 'part.dart'; |
| void f(x) {}'''); |
| Source partSource = _addSource( |
| "/part.dart", |
| r''' |
| part of lib; |
| void g() { f(null); }'''); |
| _analyzeAll_assertFinished(); |
| expect(_context.getErrors(libSource).errors, hasLength(0)); |
| expect(_context.getErrors(partSource).errors, hasLength(0)); |
| // Remove 'part' directive, which should make "f(null)" an error. |
| _context.setContents( |
| partSource, |
| r''' |
| //part of lib; |
| void g() { f(null); }'''); |
| _analyzeAll_assertFinished(); |
| expect(_context.getErrors(libSource).errors.length != 0, isTrue); |
| } |
| |
| void test_performAnalysisTask_changePartContents_noSemanticChanges() { |
| Source libSource = |
| _addSource("/test.dart", "library lib; part 'test-part.dart';"); |
| Source partSource = _addSource("/test-part.dart", "part of lib;"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 1"); |
| // update and analyze #1 |
| _context.setContents(partSource, "part of lib; // 1"); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 2"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 2"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 2"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 2"); |
| // update and analyze #2 |
| _context.setContents(partSource, "part of lib; // 12"); |
| expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, |
| reason: "library changed 3"); |
| expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, |
| reason: "part changed 3"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, |
| reason: "library resolved 3"); |
| expect( |
| _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, |
| reason: "part resolved 3"); |
| } |
| |
| void test_performAnalysisTask_getContentException_dart() { |
| // add source that throw an exception on "get content" |
| Source source = new _Source_getContent_throwException('test.dart'); |
| { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| _context.applyChanges(changeSet); |
| } |
| // prepare errors |
| _analyzeAll_assertFinished(); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| // validate errors |
| expect(errors, hasLength(1)); |
| AnalysisError error = errors[0]; |
| expect(error.source, same(source)); |
| expect(error.errorCode, ScannerErrorCode.UNABLE_GET_CONTENT); |
| } |
| |
| void test_performAnalysisTask_getContentException_html() { |
| // add source that throw an exception on "get content" |
| Source source = new _Source_getContent_throwException('test.html'); |
| { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| _context.applyChanges(changeSet); |
| } |
| // prepare errors |
| _analyzeAll_assertFinished(); |
| List<AnalysisError> errors = _context.getErrors(source).errors; |
| // validate errors |
| expect(errors, hasLength(1)); |
| AnalysisError error = errors[0]; |
| expect(error.source, same(source)); |
| expect(error.errorCode, ScannerErrorCode.UNABLE_GET_CONTENT); |
| } |
| |
| void test_performAnalysisTask_importedLibraryAdd() { |
| Source libASource = |
| _addSource("/libA.dart", "library libA; import 'libB.dart';"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull, |
| reason: "libA resolved 1"); |
| expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)), |
| isTrue, |
| reason: "libA has an error"); |
| // add libB.dart and analyze |
| Source libBSource = _addSource("/libB.dart", "library libB;"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull, |
| reason: "libA resolved 2"); |
| expect( |
| _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull, |
| reason: "libB resolved 2"); |
| expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)), |
| isTrue, |
| reason: "libA doesn't have errors"); |
| } |
| |
| void test_performAnalysisTask_importedLibraryAdd_html() { |
| Source htmlSource = _addSource( |
| "/page.html", |
| r''' |
| <html><body><script type="application/dart"> |
| import '/libB.dart'; |
| main() {print('hello dart');} |
| </script></body></html>'''); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull, |
| reason: "htmlUnit resolved 1"); |
| expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(htmlSource)), |
| isTrue, |
| reason: "htmlSource has an error"); |
| // add libB.dart and analyze |
| Source libBSource = _addSource("/libB.dart", "library libB;"); |
| _analyzeAll_assertFinished(); |
| expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull, |
| reason: "htmlUnit resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull, |
| reason: "libB resolved 2"); |
| // TODO (danrubel) commented out to fix red bots |
| // AnalysisErrorInfo errors = _context.getErrors(htmlSource); |
| // expect( |
| // !_hasAnalysisErrorWithErrorSeverity(errors), |
| // isTrue, |
| // reason: "htmlSource doesn't have errors"); |
| } |
| |
| void test_performAnalysisTask_importedLibraryDelete() { |
| Source libASource = |
| _addSource("/libA.dart", "library libA; import 'libB.dart';"); |
| Source libBSource = _addSource("/libB.dart", "library libB;"); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull, |
| reason: "libA resolved 1"); |
| expect( |
| _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull, |
| reason: "libB resolved 1"); |
| expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)), |
| isTrue, |
| reason: "libA doesn't have errors"); |
| // remove libB.dart content and analyze |
| _context.setContents(libBSource, null); |
| _analyzeAll_assertFinished(); |
| expect( |
| _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull, |
| reason: "libA resolved 2"); |
| expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)), |
| isTrue, |
| reason: "libA has an error"); |
| } |
| |
| void test_performAnalysisTask_IOException() { |
| TestSource source = _addSourceWithException2("/test.dart", "library test;"); |
| int oldTimestamp = _context.getModificationStamp(source); |
| source.generateExceptionOnRead = false; |
| _analyzeAll_assertFinished(); |
| expect(source.readCount, 1); |
| source.generateExceptionOnRead = true; |
| do { |
| _changeSource(source, ""); |
| // Ensure that the timestamp differs, |
| // so that analysis engine notices the change |
| } while (oldTimestamp == _context.getModificationStamp(source)); |
| _analyzeAll_assertFinished(); |
| expect(source.readCount, 2); |
| } |
| |
| void test_performAnalysisTask_missingPart() { |
| Source source = |
| _addSource("/test.dart", "library lib; part 'no-such-file.dart';"); |
| _analyzeAll_assertFinished(); |
| expect(_context.getLibraryElement(source), isNotNull, |
| reason: "performAnalysisTask failed to compute an element model"); |
| } |
| |
| void test_performAnalysisTask_modifiedAfterParse() { |
| // TODO(scheglov) no threads in Dart |
| // Source source = _addSource("/test.dart", "library lib;"); |
| // int initialTime = _context.getModificationStamp(source); |
| // List<Source> sources = new List<Source>(); |
| // sources.add(source); |
| // _context.analysisPriorityOrder = sources; |
| // _context.parseCompilationUnit(source); |
| // while (initialTime == JavaSystem.currentTimeMillis()) { |
| // Thread.sleep(1); |
| // // Force the modification time to be different. |
| // } |
| // _context.setContents(source, "library test;"); |
| // JUnitTestCase.assertTrue(initialTime != _context.getModificationStamp(source)); |
| // _analyzeAll_assertFinished(); |
| // JUnitTestCase.assertNotNullMsg("performAnalysisTask failed to compute an element model", _context.getLibraryElement(source)); |
| } |
| |
| void test_resolveCompilationUnit_import_relative() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| Source sourceA = |
| _addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}"); |
| _addSource("/libB.dart", "library libB; class B{}"); |
| CompilationUnit compilationUnit = |
| _context.resolveCompilationUnit2(sourceA, sourceA); |
| LibraryElement library = compilationUnit.element.library; |
| List<LibraryElement> importedLibraries = library.importedLibraries; |
| assertNamedElements(importedLibraries, ["dart.core", "libB"]); |
| List<LibraryElement> visibleLibraries = library.visibleLibraries; |
| assertNamedElements(visibleLibraries, ["dart.core", "libA", "libB"]); |
| } |
| |
| void test_resolveCompilationUnit_import_relative_cyclic() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| Source sourceA = |
| _addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}"); |
| _addSource("/libB.dart", "library libB; import 'libA.dart'; class B{}"); |
| CompilationUnit compilationUnit = |
| _context.resolveCompilationUnit2(sourceA, sourceA); |
| LibraryElement library = compilationUnit.element.library; |
| List<LibraryElement> importedLibraries = library.importedLibraries; |
| assertNamedElements(importedLibraries, ["dart.core", "libB"]); |
| List<LibraryElement> visibleLibraries = library.visibleLibraries; |
| assertNamedElements(visibleLibraries, ["dart.core", "libA", "libB"]); |
| } |
| |
| void test_resolveCompilationUnit_library() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| LibraryElement library = _context.computeLibraryElement(source); |
| CompilationUnit compilationUnit = |
| _context.resolveCompilationUnit(source, library); |
| expect(compilationUnit, isNotNull); |
| expect(compilationUnit.element, isNotNull); |
| } |
| |
| void test_resolveCompilationUnit_source() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| CompilationUnit compilationUnit = |
| _context.resolveCompilationUnit2(source, source); |
| expect(compilationUnit, isNotNull); |
| } |
| |
| void test_resolveCompilationUnit_sourceChangeDuringResolution() { |
| _context = new _AnalysisContext_sourceChangeDuringResolution(); |
| AnalysisContextFactory.initContextWithCore(_context); |
| _sourceFactory = _context.sourceFactory; |
| Source source = _addSource("/lib.dart", "library lib;"); |
| CompilationUnit compilationUnit = |
| _context.resolveCompilationUnit2(source, source); |
| expect(compilationUnit, isNotNull); |
| expect(_context.getLineInfo(source), isNotNull); |
| } |
| |
| void test_resolveHtmlUnit() { |
| Source source = _addSource("/lib.html", "<html></html>"); |
| ht.HtmlUnit unit = _context.resolveHtmlUnit(source); |
| expect(unit, isNotNull); |
| } |
| |
| void test_setAnalysisOptions() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| options.cacheSize = 42; |
| options.dart2jsHint = false; |
| options.hint = false; |
| _context.analysisOptions = options; |
| AnalysisOptions result = _context.analysisOptions; |
| expect(result.cacheSize, options.cacheSize); |
| expect(result.dart2jsHint, options.dart2jsHint); |
| expect(result.hint, options.hint); |
| } |
| |
| void test_setAnalysisOptions_reduceAnalysisPriorityOrder() { |
| AnalysisOptionsImpl options = |
| new AnalysisOptionsImpl.from(_context.analysisOptions); |
| List<Source> sources = new List<Source>(); |
| for (int index = 0; index < options.cacheSize; index++) { |
| sources.add(_addSource("/lib.dart$index", "")); |
| } |
| _context.analysisPriorityOrder = sources; |
| int oldPriorityOrderSize = _getPriorityOrder(_context).length; |
| options.cacheSize = options.cacheSize - 10; |
| _context.analysisOptions = options; |
| expect(oldPriorityOrderSize > _getPriorityOrder(_context).length, isTrue); |
| } |
| |
| void test_setAnalysisPriorityOrder_empty() { |
| _context.analysisPriorityOrder = new List<Source>(); |
| } |
| |
| void test_setAnalysisPriorityOrder_lessThanCacheSize() { |
| AnalysisOptions options = _context.analysisOptions; |
| List<Source> sources = new List<Source>(); |
| for (int index = 0; index < options.cacheSize; index++) { |
| sources.add(_addSource("/lib.dart$index", "")); |
| } |
| _context.analysisPriorityOrder = sources; |
| expect(options.cacheSize > _getPriorityOrder(_context).length, isTrue); |
| } |
| |
| void test_setAnalysisPriorityOrder_nonEmpty() { |
| List<Source> sources = new List<Source>(); |
| sources.add(_addSource("/lib.dart", "library lib;")); |
| _context.analysisPriorityOrder = sources; |
| } |
| |
| Future test_setChangedContents_libraryWithPart() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| options.incremental = true; |
| _context = AnalysisContextFactory.oldContextWithCoreAndOptions(options); |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| _sourceFactory = _context.sourceFactory; |
| String oldCode = r''' |
| library lib; |
| part 'part.dart'; |
| int a = 0;'''; |
| Source librarySource = _addSource("/lib.dart", oldCode); |
| String partContents = r''' |
| part of lib; |
| int b = a;'''; |
| Source partSource = _addSource("/part.dart", partContents); |
| LibraryElement element = _context.computeLibraryElement(librarySource); |
| CompilationUnit unit = |
| _context.getResolvedCompilationUnit(librarySource, element); |
| expect(unit, isNotNull); |
| int offset = oldCode.indexOf("int a") + 4; |
| String newCode = r''' |
| library lib; |
| part 'part.dart'; |
| int ya = 0;'''; |
| expect(_getIncrementalAnalysisCache(_context), isNull); |
| _context.setChangedContents(librarySource, newCode, offset, 0, 1); |
| expect(_context.getContents(librarySource).data, newCode); |
| IncrementalAnalysisCache incrementalCache = |
| _getIncrementalAnalysisCache(_context); |
| expect(incrementalCache.librarySource, librarySource); |
| expect(incrementalCache.resolvedUnit, same(unit)); |
| expect(_context.getResolvedCompilationUnit2(partSource, librarySource), |
| isNull); |
| expect(incrementalCache.newContents, newCode); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [partSource]); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| void test_setChangedContents_notResolved() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| AnalysisOptionsImpl options = |
| new AnalysisOptionsImpl.from(_context.analysisOptions); |
| options.incremental = true; |
| _context.analysisOptions = options; |
| _sourceFactory = _context.sourceFactory; |
| String oldCode = r''' |
| library lib; |
| int a = 0;'''; |
| Source librarySource = _addSource("/lib.dart", oldCode); |
| int offset = oldCode.indexOf("int a") + 4; |
| String newCode = r''' |
| library lib; |
| int ya = 0;'''; |
| _context.setChangedContents(librarySource, newCode, offset, 0, 1); |
| expect(_context.getContents(librarySource).data, newCode); |
| expect(_getIncrementalAnalysisCache(_context), isNull); |
| } |
| |
| Future test_setContents_libraryWithPart() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| SourcesChangedListener listener = new SourcesChangedListener(); |
| _context.onSourcesChanged.listen(listener.onData); |
| _sourceFactory = _context.sourceFactory; |
| String libraryContents1 = r''' |
| library lib; |
| part 'part.dart'; |
| int a = 0;'''; |
| Source librarySource = _addSource("/lib.dart", libraryContents1); |
| String partContents1 = r''' |
| part of lib; |
| int b = a;'''; |
| Source partSource = _addSource("/part.dart", partContents1); |
| _context.computeLibraryElement(librarySource); |
| IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache( |
| librarySource, librarySource, null, null, null, 0, 0, 0); |
| _setIncrementalAnalysisCache(_context, incrementalCache); |
| expect(_getIncrementalAnalysisCache(_context), same(incrementalCache)); |
| String libraryContents2 = r''' |
| library lib; |
| part 'part.dart'; |
| int aa = 0;'''; |
| _context.setContents(librarySource, libraryContents2); |
| expect(_context.getResolvedCompilationUnit2(partSource, librarySource), |
| isNull); |
| expect(_getIncrementalAnalysisCache(_context), isNull); |
| return pumpEventQueue().then((_) { |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertEvent(wereSourcesAdded: true); |
| listener.assertEvent(changedSources: [partSource]); |
| listener.assertEvent(changedSources: [librarySource]); |
| listener.assertNoMoreEvents(); |
| }); |
| } |
| |
| void test_setContents_null() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source librarySource = _addSource( |
| "/lib.dart", |
| r''' |
| library lib; |
| int a = 0;'''); |
| _context.computeLibraryElement(librarySource); |
| IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache( |
| librarySource, librarySource, null, null, null, 0, 0, 0); |
| _setIncrementalAnalysisCache(_context, incrementalCache); |
| expect(_getIncrementalAnalysisCache(_context), same(incrementalCache)); |
| _context.setContents(librarySource, null); |
| expect(_context.getResolvedCompilationUnit2(librarySource, librarySource), |
| isNull); |
| expect(_getIncrementalAnalysisCache(_context), isNull); |
| } |
| |
| void test_setContents_unchanged_consistentModificationTime() { |
| String contents = "// foo"; |
| Source source = _addSource("/test.dart", contents); |
| // do all, no tasks |
| _analyzeAll_assertFinished(); |
| { |
| AnalysisResult result = _context.performAnalysisTask(); |
| expect(result.changeNotices, isNull); |
| } |
| // set the same contents, still no tasks |
| _context.setContents(source, contents); |
| { |
| AnalysisResult result = _context.performAnalysisTask(); |
| expect(result.changeNotices, isNull); |
| } |
| } |
| |
| void test_setSourceFactory() { |
| expect(_context.sourceFactory, _sourceFactory); |
| SourceFactory factory = new SourceFactory([]); |
| _context.sourceFactory = factory; |
| expect(_context.sourceFactory, factory); |
| } |
| |
| void test_unreadableSource() { |
| _context = AnalysisContextFactory.oldContextWithCore(); |
| _sourceFactory = _context.sourceFactory; |
| Source test1 = _addSource( |
| "/test1.dart", |
| r''' |
| import 'test2.dart'; |
| library test1;'''); |
| Source test2 = _addSource( |
| "/test2.dart", |
| r''' |
| import 'test1.dart'; |
| import 'test3.dart'; |
| library test2;'''); |
| Source test3 = _addSourceWithException("/test3.dart"); |
| _analyzeAll_assertFinished(); |
| // test1 and test2 should have been successfully analyzed |
| // despite the fact that test3 couldn't be read. |
| expect(_context.computeLibraryElement(test1), isNotNull); |
| expect(_context.computeLibraryElement(test2), isNotNull); |
| expect(_context.computeLibraryElement(test3), isNull); |
| } |
| |
| void test_updateAnalysis() { |
| expect(_context.sourcesNeedingProcessing.isEmpty, isTrue); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| AnalysisDelta delta = new AnalysisDelta(); |
| delta.setAnalysisLevel(source, AnalysisLevel.ALL); |
| _context.applyAnalysisDelta(delta); |
| expect(_context.sourcesNeedingProcessing.contains(source), isTrue); |
| delta = new AnalysisDelta(); |
| delta.setAnalysisLevel(source, AnalysisLevel.NONE); |
| _context.applyAnalysisDelta(delta); |
| expect(_context.sourcesNeedingProcessing.contains(source), isFalse); |
| } |
| |
| void xtest_performAnalysisTask_stress() { |
| int maxCacheSize = 4; |
| AnalysisOptionsImpl options = |
| new AnalysisOptionsImpl.from(_context.analysisOptions); |
| options.cacheSize = maxCacheSize; |
| _context.analysisOptions = options; |
| int sourceCount = maxCacheSize + 2; |
| List<Source> sources = new List<Source>(); |
| ChangeSet changeSet = new ChangeSet(); |
| for (int i = 0; i < sourceCount; i++) { |
| Source source = _addSource("/lib$i.dart", "library lib$i;"); |
| sources.add(source); |
| changeSet.addedSource(source); |
| } |
| _context.applyChanges(changeSet); |
| _context.analysisPriorityOrder = sources; |
| for (int i = 0; i < 1000; i++) { |
| List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices; |
| if (notice == null) { |
| //System.out.println("test_performAnalysisTask_stress: " + i); |
| break; |
| } |
| } |
| List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices; |
| if (notice != null) { |
| fail( |
| "performAnalysisTask failed to terminate after analyzing all sources"); |
| } |
| } |
| |
| Source _addSource(String fileName, String contents) { |
| Source source = new FileBasedSource(FileUtilities2.createFile(fileName)); |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| _context.applyChanges(changeSet); |
| _context.setContents(source, contents); |
| return source; |
| } |
| |
| TestSource _addSourceWithException(String fileName) { |
| return _addSourceWithException2(fileName, ""); |
| } |
| |
| TestSource _addSourceWithException2(String fileName, String contents) { |
| TestSource source = new TestSource(fileName, contents); |
| source.generateExceptionOnRead = true; |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| _context.applyChanges(changeSet); |
| return source; |
| } |
| |
| /** |
| * Perform analysis tasks up to 512 times and asserts that that was enough. |
| */ |
| void _analyzeAll_assertFinished() { |
| _analyzeAll_assertFinished2(512); |
| } |
| |
| /** |
| * Perform analysis tasks up to the given number of times and asserts that that was enough. |
| * |
| * @param maxIterations the maximum number of tasks to perform |
| */ |
| void _analyzeAll_assertFinished2(int maxIterations) { |
| for (int i = 0; i < maxIterations; i++) { |
| List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices; |
| if (notice == null) { |
| return; |
| } |
| } |
| fail("performAnalysisTask failed to terminate after analyzing all sources"); |
| } |
| |
| void _changeSource(TestSource source, String contents) { |
| source.setContents(contents); |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.changedSource(source); |
| _context.applyChanges(changeSet); |
| } |
| |
| Source _createSource(String fileName, String contents) { |
| Source source = new FileBasedSource(FileUtilities2.createFile(fileName)); |
| _context.setContents(source, contents); |
| return source; |
| } |
| |
| /** |
| * Search the given compilation unit for a class with the given name. Return the class with the |
| * given name, or `null` if the class cannot be found. |
| * |
| * @param unit the compilation unit being searched |
| * @param className the name of the class being searched for |
| * @return the class with the given name |
| */ |
| ClassElement _findClass(CompilationUnitElement unit, String className) { |
| for (ClassElement classElement in unit.types) { |
| if (classElement.displayName == className) { |
| return classElement; |
| } |
| } |
| return null; |
| } |
| |
| IncrementalAnalysisCache _getIncrementalAnalysisCache( |
| AnalysisContextImpl context2) { |
| return context2.test_incrementalAnalysisCache; |
| } |
| |
| List<Source> _getPriorityOrder(AnalysisContextImpl context2) { |
| return context2.test_priorityOrder; |
| } |
| |
| void _performPendingAnalysisTasks([int maxTasks = 20]) { |
| for (int i = 0; _context.performAnalysisTask().hasMoreWork; i++) { |
| if (i > maxTasks) { |
| fail('Analysis did not terminate.'); |
| } |
| } |
| } |
| |
| void _removeSource(Source source) { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.removedSource(source); |
| _context.applyChanges(changeSet); |
| } |
| |
| void _setIncrementalAnalysisCache( |
| AnalysisContextImpl context, IncrementalAnalysisCache incrementalCache) { |
| context.test_incrementalAnalysisCache = incrementalCache; |
| } |
| |
| /** |
| * Returns `true` if there is an [AnalysisError] with [ErrorSeverity.ERROR] in |
| * the given [AnalysisErrorInfo]. |
| */ |
| static bool _hasAnalysisErrorWithErrorSeverity(AnalysisErrorInfo errorInfo) { |
| List<AnalysisError> errors = errorInfo.errors; |
| for (AnalysisError analysisError in errors) { |
| if (analysisError.errorCode.errorSeverity == ErrorSeverity.ERROR) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| |
| class AnalysisContextImplTest_Source_exists_true extends TestSource { |
| @override |
| bool exists() => true; |
| } |
| |
| class AnalysisContextImplTest_Source_getModificationStamp_fromSource |
| extends TestSource { |
| int stamp; |
| AnalysisContextImplTest_Source_getModificationStamp_fromSource(this.stamp); |
| @override |
| int get modificationStamp => stamp; |
| } |
| |
| class AnalysisContextImplTest_Source_getModificationStamp_overridden |
| extends TestSource { |
| int stamp; |
| AnalysisContextImplTest_Source_getModificationStamp_overridden(this.stamp); |
| @override |
| int get modificationStamp => stamp; |
| } |
| |
| @reflectiveTest |
| class AnalysisOptionsImplTest extends EngineTestCase { |
| void test_AnalysisOptionsImpl_copy() { |
| bool booleanValue = true; |
| for (int i = 0; i < 2; i++, booleanValue = !booleanValue) { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| options.analyzeFunctionBodies = booleanValue; |
| options.cacheSize = i; |
| options.dart2jsHint = booleanValue; |
| options.enableStrictCallChecks = booleanValue; |
| options.enableSuperMixins = booleanValue; |
| options.generateImplicitErrors = booleanValue; |
| options.generateSdkErrors = booleanValue; |
| options.hint = booleanValue; |
| options.incremental = booleanValue; |
| options.preserveComments = booleanValue; |
| options.strongMode = booleanValue; |
| AnalysisOptionsImpl copy = new AnalysisOptionsImpl.from(options); |
| expect(copy.analyzeFunctionBodies, options.analyzeFunctionBodies); |
| expect(copy.cacheSize, options.cacheSize); |
| expect(copy.dart2jsHint, options.dart2jsHint); |
| expect(copy.enableStrictCallChecks, options.enableStrictCallChecks); |
| expect(copy.enableSuperMixins, options.enableSuperMixins); |
| expect(copy.generateImplicitErrors, options.generateImplicitErrors); |
| expect(copy.generateSdkErrors, options.generateSdkErrors); |
| expect(copy.hint, options.hint); |
| expect(copy.incremental, options.incremental); |
| expect(copy.preserveComments, options.preserveComments); |
| expect(copy.strongMode, options.strongMode); |
| } |
| } |
| |
| void test_analyzeFunctionBodies() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.analyzeFunctionBodies; |
| options.analyzeFunctionBodies = value; |
| expect(options.analyzeFunctionBodies, value); |
| } |
| |
| void test_cacheSize() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| expect(options.cacheSize, AnalysisOptionsImpl.DEFAULT_CACHE_SIZE); |
| int value = options.cacheSize + 1; |
| options.cacheSize = value; |
| expect(options.cacheSize, value); |
| } |
| |
| void test_dart2jsHint() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.dart2jsHint; |
| options.dart2jsHint = value; |
| expect(options.dart2jsHint, value); |
| } |
| |
| void test_enableSuperMixins() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.enableSuperMixins; |
| options.enableSuperMixins = value; |
| expect(options.enableSuperMixins, value); |
| } |
| |
| void test_generateImplicitErrors() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.generateImplicitErrors; |
| options.generateImplicitErrors = value; |
| expect(options.generateImplicitErrors, value); |
| } |
| |
| void test_generateSdkErrors() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.generateSdkErrors; |
| options.generateSdkErrors = value; |
| expect(options.generateSdkErrors, value); |
| } |
| |
| void test_hint() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.hint; |
| options.hint = value; |
| expect(options.hint, value); |
| } |
| |
| void test_incremental() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.incremental; |
| options.incremental = value; |
| expect(options.incremental, value); |
| } |
| |
| void test_preserveComments() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.preserveComments; |
| options.preserveComments = value; |
| expect(options.preserveComments, value); |
| } |
| |
| void test_strongMode() { |
| AnalysisOptionsImpl options = new AnalysisOptionsImpl(); |
| bool value = !options.strongMode; |
| options.strongMode = value; |
| expect(options.strongMode, value); |
| } |
| } |
| |
| class AnalysisTask_test_perform_exception extends AnalysisTask { |
| AnalysisTask_test_perform_exception(InternalAnalysisContext arg0) |
| : super(arg0); |
| @override |
| String get taskDescription => null; |
| @override |
| accept(AnalysisTaskVisitor visitor) { |
| expect(exception, isNotNull); |
| return null; |
| } |
| |
| @override |
| void internalPerform() { |
| throw new AnalysisException("Forced exception"); |
| } |
| } |
| |
| @reflectiveTest |
| class AnalysisTaskTest extends EngineTestCase { |
| void test_perform_exception() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| AnalysisTask task = new AnalysisTask_test_perform_exception(context); |
| task.perform(new TestTaskVisitor<Object>()); |
| } |
| } |
| |
| /** |
| * A listener used to gather the [ImplicitAnalysisEvent]s that are produced |
| * during analysis. |
| */ |
| class AnalyzedSourcesListener { |
| /** |
| * The events that have been gathered. |
| */ |
| List<ImplicitAnalysisEvent> actualEvents = <ImplicitAnalysisEvent>[]; |
| |
| /** |
| * The sources that are being implicitly analyzed. |
| */ |
| List<Source> analyzedSources = <Source>[]; |
| |
| /** |
| * Assert that the given source is currently being implicitly analyzed. |
| */ |
| void expectAnalyzed(Source source) { |
| expect(analyzedSources, contains(source)); |
| } |
| |
| /** |
| * Assert that the given source is not currently being implicitly analyzed. |
| */ |
| void expectNotAnalyzed(Source source) { |
| expect(analyzedSources, isNot(contains(source))); |
| } |
| |
| /** |
| * Record that the given event was produced. |
| */ |
| void onData(ImplicitAnalysisEvent event) { |
| actualEvents.add(event); |
| if (event.isAnalyzed) { |
| analyzedSources.add(event.source); |
| } else { |
| analyzedSources.remove(event.source); |
| } |
| } |
| } |
| |
| class CompilationUnitMock extends TypedMock implements CompilationUnit { |
| noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation); |
| } |
| |
| @reflectiveTest |
| class DartEntryTest extends EngineTestCase { |
| void test_allErrors() { |
| Source source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| expect(entry.allErrors, hasLength(0)); |
| entry.setValue(SourceEntry.CONTENT_ERRORS, <AnalysisError>[ |
| new AnalysisError(source, 0, 0, ScannerErrorCode.UNABLE_GET_CONTENT, |
| ['exception details']) |
| ]); |
| entry.setValue(DartEntry.SCAN_ERRORS, <AnalysisError>[ |
| new AnalysisError( |
| source, 0, 0, ScannerErrorCode.UNTERMINATED_STRING_LITERAL) |
| ]); |
| entry.setValue(DartEntry.PARSE_ERRORS, <AnalysisError>[ |
| new AnalysisError(source, 0, 0, ParserErrorCode.ABSTRACT_CLASS_MEMBER) |
| ]); |
| entry.setValueInLibrary( |
| DartEntry.RESOLUTION_ERRORS, source, <AnalysisError>[ |
| new AnalysisError( |
| source, 0, 0, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION) |
| ]); |
| entry.setValueInLibrary( |
| DartEntry.VERIFICATION_ERRORS, source, <AnalysisError>[ |
| new AnalysisError( |
| source, 0, 0, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED) |
| ]); |
| entry.setValueInLibrary(DartEntry.HINTS, source, |
| <AnalysisError>[new AnalysisError(source, 0, 0, HintCode.DEAD_CODE)]); |
| expect(entry.allErrors, hasLength(6)); |
| } |
| |
| void test_creation() { |
| Source librarySource = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.INVALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.CONTAINING_LIBRARIES), |
| same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.INVALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| } |
| |
| void test_getResolvableCompilationUnit_none() { |
| DartEntry entry = new DartEntry(); |
| expect(entry.resolvableCompilationUnit, isNull); |
| } |
| |
| void test_getResolvableCompilationUnit_parsed_accessed() { |
| 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"; |
| Source exportSource = new TestSource(exportUri); |
| ExportDirective exportDirective = AstFactory.exportDirective2(exportUri); |
| exportDirective.source = exportSource; |
| exportDirective.uriContent = exportUri; |
| 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; |
| expect(result, same(unit)); |
| entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit); |
| result = entry.resolvableCompilationUnit; |
| expect(result, isNot(same(unit))); |
| NodeList<Directive> directives = result.directives; |
| ImportDirective resultImportDirective = directives[0] as ImportDirective; |
| expect(resultImportDirective.uriContent, importUri); |
| expect(resultImportDirective.source, same(importSource)); |
| ExportDirective resultExportDirective = directives[1] as ExportDirective; |
| expect(resultExportDirective.uriContent, exportUri); |
| expect(resultExportDirective.source, same(exportSource)); |
| PartDirective resultPartDirective = directives[2] as PartDirective; |
| expect(resultPartDirective.uriContent, partUri); |
| expect(resultPartDirective.source, same(partSource)); |
| } |
| |
| void test_getResolvableCompilationUnit_parsed_notAccessed() { |
| CompilationUnit unit = AstFactory.compilationUnit(); |
| DartEntry entry = new DartEntry(); |
| entry.setValue(DartEntry.PARSED_UNIT, unit); |
| expect(entry.resolvableCompilationUnit, same(unit)); |
| } |
| |
| void test_getResolvableCompilationUnit_resolved() { |
| 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"; |
| Source exportSource = new TestSource(exportUri); |
| ExportDirective exportDirective = AstFactory.exportDirective2(exportUri); |
| exportDirective.source = exportSource; |
| exportDirective.uriContent = exportUri; |
| 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.setValueInLibrary( |
| DartEntry.RESOLVED_UNIT, new TestSource("lib.dart"), unit); |
| CompilationUnit result = entry.resolvableCompilationUnit; |
| expect(result, isNot(same(unit))); |
| NodeList<Directive> directives = result.directives; |
| ImportDirective resultImportDirective = directives[0] as ImportDirective; |
| expect(resultImportDirective.uriContent, importUri); |
| expect(resultImportDirective.source, same(importSource)); |
| ExportDirective resultExportDirective = directives[1] as ExportDirective; |
| expect(resultExportDirective.uriContent, exportUri); |
| expect(resultExportDirective.source, same(exportSource)); |
| PartDirective resultPartDirective = directives[2] as PartDirective; |
| expect(resultPartDirective.uriContent, partUri); |
| expect(resultPartDirective.source, same(partSource)); |
| } |
| |
| void test_getState_invalid_resolutionErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getState(DartEntry.RESOLUTION_ERRORS); |
| fail("Expected ArgumentError for RESOLUTION_ERRORS"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_getState_invalid_verificationErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getState(DartEntry.VERIFICATION_ERRORS); |
| fail("Expected ArgumentError for VERIFICATION_ERRORS"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_getStateInLibrary_invalid_element() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getStateInLibrary(DartEntry.ELEMENT, new TestSource()); |
| fail("Expected ArgumentError for ELEMENT"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_getValue_containingLibraries() { |
| Source testSource = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| List<Source> value = entry.containingLibraries; |
| expect(value, hasLength(0)); |
| entry.addContainingLibrary(testSource); |
| value = entry.containingLibraries; |
| expect(value, hasLength(1)); |
| expect(value[0], testSource); |
| entry.removeContainingLibrary(testSource); |
| value = entry.containingLibraries; |
| expect(value, hasLength(0)); |
| } |
| |
| void test_getValue_invalid_resolutionErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getValue(DartEntry.RESOLUTION_ERRORS); |
| fail("Expected ArgumentError for RESOLUTION_ERRORS"); |
| } on ArgumentError {} |
| } |
| |
| void test_getValue_invalid_verificationErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getValue(DartEntry.VERIFICATION_ERRORS); |
| fail("Expected ArgumentError for VERIFICATION_ERRORS"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_getValueInLibrary_invalid_element() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.getValueInLibrary(DartEntry.ELEMENT, new TestSource()); |
| fail("Expected ArgumentError for ELEMENT"); |
| } on ArgumentError { |
| // 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); |
| fail("Expected ArgumentError for ELEMENT"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_hasInvalidData_false() { |
| DartEntry entry = new DartEntry(); |
| entry.recordScanError(new CaughtException(new AnalysisException(), null)); |
| expect(entry.hasInvalidData(DartEntry.ELEMENT), isFalse); |
| expect(entry.hasInvalidData(DartEntry.EXPORTED_LIBRARIES), isFalse); |
| expect(entry.hasInvalidData(DartEntry.HINTS), isFalse); |
| expect(entry.hasInvalidData(DartEntry.IMPORTED_LIBRARIES), isFalse); |
| expect(entry.hasInvalidData(DartEntry.INCLUDED_PARTS), isFalse); |
| expect(entry.hasInvalidData(DartEntry.IS_CLIENT), isFalse); |
| expect(entry.hasInvalidData(DartEntry.IS_LAUNCHABLE), isFalse); |
| expect(entry.hasInvalidData(SourceEntry.LINE_INFO), isFalse); |
| expect(entry.hasInvalidData(DartEntry.PARSE_ERRORS), isFalse); |
| expect(entry.hasInvalidData(DartEntry.PARSED_UNIT), isFalse); |
| expect(entry.hasInvalidData(DartEntry.PUBLIC_NAMESPACE), isFalse); |
| expect(entry.hasInvalidData(DartEntry.SOURCE_KIND), isFalse); |
| expect(entry.hasInvalidData(DartEntry.RESOLUTION_ERRORS), isFalse); |
| expect(entry.hasInvalidData(DartEntry.RESOLVED_UNIT), isFalse); |
| expect(entry.hasInvalidData(DartEntry.VERIFICATION_ERRORS), isFalse); |
| } |
| |
| void test_hasInvalidData_true() { |
| DartEntry entry = new DartEntry(); |
| expect(entry.hasInvalidData(DartEntry.ELEMENT), isTrue); |
| expect(entry.hasInvalidData(DartEntry.EXPORTED_LIBRARIES), isTrue); |
| expect(entry.hasInvalidData(DartEntry.HINTS), isTrue); |
| expect(entry.hasInvalidData(DartEntry.IMPORTED_LIBRARIES), isTrue); |
| expect(entry.hasInvalidData(DartEntry.INCLUDED_PARTS), isTrue); |
| expect(entry.hasInvalidData(DartEntry.IS_CLIENT), isTrue); |
| expect(entry.hasInvalidData(DartEntry.IS_LAUNCHABLE), isTrue); |
| expect(entry.hasInvalidData(SourceEntry.LINE_INFO), isTrue); |
| expect(entry.hasInvalidData(DartEntry.PARSE_ERRORS), isTrue); |
| expect(entry.hasInvalidData(DartEntry.PARSED_UNIT), isTrue); |
| expect(entry.hasInvalidData(DartEntry.PUBLIC_NAMESPACE), isTrue); |
| expect(entry.hasInvalidData(DartEntry.SOURCE_KIND), isTrue); |
| expect(entry.hasInvalidData(DartEntry.RESOLUTION_ERRORS), isTrue); |
| expect(entry.hasInvalidData(DartEntry.RESOLVED_UNIT), isTrue); |
| expect(entry.hasInvalidData(DartEntry.VERIFICATION_ERRORS), isTrue); |
| } |
| |
| void test_invalidateAllInformation() { |
| Source librarySource = new TestSource(); |
| DartEntry entry = _entryWithValidState(librarySource); |
| entry.invalidateAllInformation(); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.INVALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.INVALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| } |
| |
| void test_invalidateAllResolutionInformation() { |
| Source librarySource = new TestSource(); |
| DartEntry entry = _entryWithValidState(librarySource); |
| entry.invalidateAllResolutionInformation(false); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| } |
| |
| void test_invalidateAllResolutionInformation_includingUris() { |
| Source librarySource = new TestSource(); |
| DartEntry entry = _entryWithValidState(librarySource); |
| entry.invalidateAllResolutionInformation(true); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.INVALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), |
| same(CacheState.INVALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource), |
| same(CacheState.INVALID)); |
| } |
| |
| void test_isClient() { |
| DartEntry entry = new DartEntry(); |
| // true |
| entry.setValue(DartEntry.IS_CLIENT, true); |
| expect(entry.getValue(DartEntry.IS_CLIENT), isTrue); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.VALID)); |
| // invalidate |
| entry.setState(DartEntry.IS_CLIENT, CacheState.INVALID); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.INVALID)); |
| // false |
| entry.setValue(DartEntry.IS_CLIENT, false); |
| expect(entry.getValue(DartEntry.IS_CLIENT), isFalse); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.VALID)); |
| } |
| |
| void test_isLaunchable() { |
| DartEntry entry = new DartEntry(); |
| // true |
| entry.setValue(DartEntry.IS_LAUNCHABLE, true); |
| expect(entry.getValue(DartEntry.IS_LAUNCHABLE), isTrue); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.VALID)); |
| // invalidate |
| entry.setState(DartEntry.IS_LAUNCHABLE, CacheState.INVALID); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.INVALID)); |
| // false |
| entry.setValue(DartEntry.IS_LAUNCHABLE, false); |
| expect(entry.getValue(DartEntry.IS_LAUNCHABLE), isFalse); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.VALID)); |
| } |
| |
| void test_recordBuildElementError() { |
| Source firstLibrary = new TestSource('first.dart'); |
| Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary, secondLibrary); |
| entry.recordBuildElementErrorInLibrary( |
| firstLibrary, new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| } |
| |
| void test_recordContentError() { |
| Source firstLibrary = new TestSource('first.dart'); |
| // Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary); |
| entry |
| .recordContentError(new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.ERROR)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.ERROR)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| // The following lines are commented out because we don't currently have |
| // any way of setting the state for data associated with a library we |
| // don't know anything about. |
| // expect(entry.getStateInLibrary(DartEntry.ANGULAR_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| } |
| |
| void test_recordHintErrorInLibrary() { |
| Source firstLibrary = new TestSource('first.dart'); |
| Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary, secondLibrary); |
| entry.recordHintErrorInLibrary( |
| firstLibrary, new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| } |
| |
| void test_recordParseError() { |
| Source firstLibrary = new TestSource('first.dart'); |
| // Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary); |
| entry.recordParseError(new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| // The following lines are commented out because we don't currently have |
| // any way of setting the state for data associated with a library we |
| // don't know anything about. |
| // expect(entry.getStateInLibrary(DartEntry.ANGULAR_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| } |
| |
| void test_recordResolutionError() { |
| Source firstLibrary = new TestSource('first.dart'); |
| // Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary); |
| entry.recordResolutionError( |
| new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| // The following lines are commented out because we don't currently have |
| // any way of setting the state for data associated with a library we |
| // don't know anything about. |
| // expect(entry.getStateInLibrary(DartEntry.ANGULAR_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| } |
| |
| void test_recordResolutionErrorInLibrary() { |
| Source firstLibrary = new TestSource('first.dart'); |
| Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary, secondLibrary); |
| entry.recordResolutionErrorInLibrary( |
| firstLibrary, new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| } |
| |
| void test_recordScanError() { |
| Source firstLibrary = new TestSource('first.dart'); |
| // Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary); |
| entry.recordScanError(new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.ERROR)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.ERROR)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| // The following lines are commented out because we don't currently have |
| // any way of setting the state for data associated with a library we |
| // don't know anything about. |
| // expect(entry.getStateInLibrary(DartEntry.ANGULAR_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), same(CacheState.ERROR)); |
| // expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), same(CacheState.ERROR)); |
| } |
| |
| void test_recordVerificationErrorInLibrary() { |
| Source firstLibrary = new TestSource('first.dart'); |
| Source secondLibrary = new TestSource('second.dart'); |
| DartEntry entry = _entryWithValidState(firstLibrary, secondLibrary); |
| entry.recordVerificationErrorInLibrary( |
| firstLibrary, new CaughtException(new AnalysisException(), null)); |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.ERROR)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.ERROR)); |
| |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| } |
| |
| void test_removeResolution_multiple_first() { |
| Source source1 = new TestSource('first.dart'); |
| Source source2 = new TestSource('second.dart'); |
| Source source3 = new TestSource('third.dart'); |
| 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()); |
| entry.removeResolution(source1); |
| } |
| |
| void test_removeResolution_multiple_last() { |
| Source source1 = new TestSource('first.dart'); |
| Source source2 = new TestSource('second.dart'); |
| Source source3 = new TestSource('third.dart'); |
| 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()); |
| entry.removeResolution(source3); |
| } |
| |
| void test_removeResolution_multiple_middle() { |
| Source source1 = new TestSource('first.dart'); |
| Source source2 = new TestSource('second.dart'); |
| Source source3 = new TestSource('third.dart'); |
| 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()); |
| entry.removeResolution(source2); |
| } |
| |
| void test_removeResolution_single() { |
| Source source1 = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| entry.setValueInLibrary( |
| DartEntry.RESOLVED_UNIT, source1, AstFactory.compilationUnit()); |
| entry.removeResolution(source1); |
| } |
| |
| void test_resolvableCompilationUnit_builtUnit() { |
| Source librarySource = new TestSource('/lib.dart'); |
| CompilationUnit unit = AstFactory.compilationUnit(); |
| CompilationUnitElement element = |
| ElementFactory.compilationUnit('test.dart'); |
| unit.element = element; |
| DartEntry entry = new DartEntry(); |
| entry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED); |
| entry.setValueInLibrary(DartEntry.BUILT_UNIT, librarySource, unit); |
| entry.invalidateAllResolutionInformation(false); |
| CompilationUnit resolvableUnit = entry.resolvableCompilationUnit; |
| expect(resolvableUnit, isNotNull); |
| expect(resolvableUnit.element, isNull); |
| expect(entry.resolvableCompilationUnit, isNull); |
| } |
| |
| void test_resolvableCompilationUnit_none() { |
| DartEntry entry = new DartEntry(); |
| expect(entry.resolvableCompilationUnit, isNull); |
| } |
| |
| void test_resolvableCompilationUnit_parsed() { |
| CompilationUnit unit = AstFactory.compilationUnit(); |
| DartEntry entry = new DartEntry(); |
| entry.setValue(DartEntry.PARSED_UNIT, unit); |
| expect(entry.resolvableCompilationUnit, unit); |
| expect(entry.resolvableCompilationUnit, isNull); |
| } |
| |
| void test_resolvableCompilationUnit_resolved() { |
| Source librarySource = new TestSource('/lib.dart'); |
| CompilationUnit unit = AstFactory.compilationUnit(); |
| CompilationUnitElement element = |
| ElementFactory.compilationUnit('test.dart'); |
| unit.element = element; |
| DartEntry entry = new DartEntry(); |
| entry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED); |
| entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit); |
| entry.invalidateAllResolutionInformation(false); |
| CompilationUnit resolvableUnit = entry.resolvableCompilationUnit; |
| expect(resolvableUnit, isNotNull); |
| expect(resolvableUnit.element, isNull); |
| expect(entry.resolvableCompilationUnit, isNull); |
| } |
| |
| void test_setState_element() { |
| _setState(DartEntry.ELEMENT); |
| } |
| |
| void test_setState_exportedLibraries() { |
| _setState(DartEntry.EXPORTED_LIBRARIES); |
| } |
| |
| void test_setState_hints() { |
| _setStateInLibrary(DartEntry.HINTS); |
| } |
| |
| void test_setState_importedLibraries() { |
| _setState(DartEntry.IMPORTED_LIBRARIES); |
| } |
| |
| void test_setState_includedParts() { |
| _setState(DartEntry.INCLUDED_PARTS); |
| } |
| |
| void test_setState_invalid_element() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.setStateInLibrary(DartEntry.ELEMENT, null, CacheState.FLUSHED); |
| fail("Expected ArgumentError for ELEMENT"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_setState_invalid_resolutionErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.setState(DartEntry.RESOLUTION_ERRORS, CacheState.FLUSHED); |
| fail("Expected ArgumentError for RESOLUTION_ERRORS"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_setState_invalid_validState() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.setState(SourceEntry.LINE_INFO, CacheState.VALID); |
| fail("Expected ArgumentError for a state of VALID"); |
| } on ArgumentError {} |
| } |
| |
| void test_setState_invalid_verificationErrors() { |
| DartEntry entry = new DartEntry(); |
| try { |
| entry.setState(DartEntry.VERIFICATION_ERRORS, CacheState.FLUSHED); |
| fail("Expected ArgumentError for VERIFICATION_ERRORS"); |
| } on ArgumentError { |
| // Expected |
| } |
| } |
| |
| void test_setState_isClient() { |
| _setState(DartEntry.IS_CLIENT); |
| } |
| |
| void test_setState_isLaunchable() { |
| _setState(DartEntry.IS_LAUNCHABLE); |
| } |
| |
| void test_setState_lineInfo() { |
| _setState(SourceEntry.LINE_INFO); |
| } |
| |
| void test_setState_parsedUnit() { |
| _setState(DartEntry.PARSED_UNIT); |
| } |
| |
| void test_setState_parseErrors() { |
| _setState(DartEntry.PARSE_ERRORS); |
| } |
| |
| void test_setState_publicNamespace() { |
| _setState(DartEntry.PUBLIC_NAMESPACE); |
| } |
| |
| void test_setState_resolutionErrors() { |
| _setStateInLibrary(DartEntry.RESOLUTION_ERRORS); |
| } |
| |
| void test_setState_resolvedUnit() { |
| _setStateInLibrary(DartEntry.RESOLVED_UNIT); |
| } |
| |
| void test_setState_scanErrors() { |
| _setState(DartEntry.SCAN_ERRORS); |
| } |
| |
| void test_setState_sourceKind() { |
| _setState(DartEntry.SOURCE_KIND); |
| } |
| |
| void test_setState_tokenStream() { |
| _setState(DartEntry.TOKEN_STREAM); |
| } |
| |
| void test_setState_verificationErrors() { |
| _setStateInLibrary(DartEntry.VERIFICATION_ERRORS); |
| } |
| |
| void test_setValue_element() { |
| _setValue( |
| DartEntry.ELEMENT, |
| new LibraryElementImpl.forNode( |
| null, AstFactory.libraryIdentifier2(["lib"]))); |
| } |
| |
| void test_setValue_exportedLibraries() { |
| _setValue(DartEntry.EXPORTED_LIBRARIES, <Source>[new TestSource()]); |
| } |
| |
| void test_setValue_hints() { |
| _setValueInLibrary(DartEntry.HINTS, |
| <AnalysisError>[new AnalysisError(null, 0, 0, HintCode.DEAD_CODE)]); |
| } |
| |
| void test_setValue_importedLibraries() { |
| _setValue(DartEntry.IMPORTED_LIBRARIES, <Source>[new TestSource()]); |
| } |
| |
| void test_setValue_includedParts() { |
| _setValue(DartEntry.INCLUDED_PARTS, <Source>[new TestSource()]); |
| } |
| |
| void test_setValue_isClient() { |
| _setValue(DartEntry.IS_CLIENT, true); |
| } |
| |
| void test_setValue_isLaunchable() { |
| _setValue(DartEntry.IS_LAUNCHABLE, true); |
| } |
| |
| void test_setValue_lineInfo() { |
| _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0])); |
| } |
| |
| void test_setValue_parsedUnit() { |
| _setValue(DartEntry.PARSED_UNIT, AstFactory.compilationUnit()); |
| } |
| |
| void test_setValue_parseErrors() { |
| _setValue(DartEntry.PARSE_ERRORS, <AnalysisError>[ |
| new AnalysisError(null, 0, 0, ParserErrorCode.ABSTRACT_CLASS_MEMBER) |
| ]); |
| } |
| |
| void test_setValue_publicNamespace() { |
| _setValue(DartEntry.PUBLIC_NAMESPACE, |
| new Namespace(new HashMap<String, Element>())); |
| } |
| |
| void test_setValue_resolutionErrors() { |
| _setValueInLibrary(DartEntry.RESOLUTION_ERRORS, <AnalysisError>[ |
| new AnalysisError( |
| null, 0, 0, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION) |
| ]); |
| } |
| |
| void test_setValue_resolvedUnit() { |
| _setValueInLibrary(DartEntry.RESOLVED_UNIT, AstFactory.compilationUnit()); |
| } |
| |
| void test_setValue_scanErrors() { |
| _setValue(DartEntry.SCAN_ERRORS, <AnalysisError>[ |
| new AnalysisError( |
| null, 0, 0, ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT) |
| ]); |
| } |
| |
| void test_setValue_sourceKind() { |
| _setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY); |
| } |
| |
| void test_setValue_tokenStream() { |
| _setValue(DartEntry.TOKEN_STREAM, new Token(TokenType.LT, 5)); |
| } |
| |
| void test_setValue_verificationErrors() { |
| _setValueInLibrary(DartEntry.VERIFICATION_ERRORS, <AnalysisError>[ |
| new AnalysisError(null, 0, 0, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED) |
| ]); |
| } |
| |
| DartEntry _entryWithValidState([Source firstLibrary, Source secondLibrary]) { |
| DartEntry entry = new DartEntry(); |
| entry.setValue(SourceEntry.CONTENT, null); |
| entry.setValue(SourceEntry.CONTENT_ERRORS, null); |
| entry.setValue(SourceEntry.LINE_INFO, null); |
| entry.setValue(DartEntry.CONTAINING_LIBRARIES, null); |
| entry.setValue(DartEntry.ELEMENT, null); |
| entry.setValue(DartEntry.EXPORTED_LIBRARIES, null); |
| entry.setValue(DartEntry.IMPORTED_LIBRARIES, null); |
| entry.setValue(DartEntry.INCLUDED_PARTS, null); |
| entry.setValue(DartEntry.IS_CLIENT, null); |
| entry.setValue(DartEntry.IS_LAUNCHABLE, null); |
| entry.setValue(DartEntry.PARSE_ERRORS, null); |
| entry.setValue(DartEntry.PARSED_UNIT, null); |
| entry.setValue(DartEntry.PUBLIC_NAMESPACE, null); |
| entry.setValue(DartEntry.SCAN_ERRORS, null); |
| entry.setValue(DartEntry.SOURCE_KIND, null); |
| entry.setValue(DartEntry.TOKEN_STREAM, null); |
| if (firstLibrary != null) { |
| entry.setValueInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary, null); |
| entry.setValueInLibrary(DartEntry.BUILT_UNIT, firstLibrary, null); |
| entry.setValueInLibrary(DartEntry.HINTS, firstLibrary, null); |
| entry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary, null); |
| entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary, null); |
| entry.setValueInLibrary( |
| DartEntry.VERIFICATION_ERRORS, firstLibrary, null); |
| } |
| if (secondLibrary != null) { |
| entry.setValueInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary, null); |
| entry.setValueInLibrary(DartEntry.BUILT_UNIT, secondLibrary, null); |
| entry.setValueInLibrary(DartEntry.HINTS, secondLibrary, null); |
| entry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary, null); |
| entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary, null); |
| entry.setValueInLibrary( |
| DartEntry.VERIFICATION_ERRORS, secondLibrary, null); |
| } |
| // |
| // Validate that the state was set correctly. |
| // |
| expect(entry.getState(SourceEntry.CONTENT), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.CONTENT_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.ELEMENT), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.EXPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(DartEntry.IMPORTED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.INCLUDED_PARTS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_CLIENT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.IS_LAUNCHABLE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.PUBLIC_NAMESPACE), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SCAN_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.SOURCE_KIND), same(CacheState.VALID)); |
| expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.VALID)); |
| if (firstLibrary != null) { |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, firstLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, firstLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, firstLibrary), |
| same(CacheState.VALID)); |
| } |
| if (secondLibrary != null) { |
| expect(entry.getStateInLibrary(DartEntry.BUILT_ELEMENT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.BUILT_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.HINTS, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, secondLibrary), |
| same(CacheState.VALID)); |
| expect( |
| entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, secondLibrary), |
| same(CacheState.VALID)); |
| } |
| return entry; |
| } |
| |
| void _setState(DataDescriptor descriptor) { |
| DartEntry entry = new DartEntry(); |
| expect(entry.getState(descriptor), isNot(same(CacheState.FLUSHED))); |
| entry.setState(descriptor, CacheState.FLUSHED); |
| expect(entry.getState(descriptor), same(CacheState.FLUSHED)); |
| } |
| |
| void _setStateInLibrary(DataDescriptor descriptor) { |
| Source source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| expect(entry.getStateInLibrary(descriptor, source), |
| isNot(same(CacheState.FLUSHED))); |
| entry.setStateInLibrary(descriptor, source, CacheState.FLUSHED); |
| expect( |
| entry.getStateInLibrary(descriptor, source), same(CacheState.FLUSHED)); |
| } |
| |
| void _setValue(DataDescriptor descriptor, Object newValue) { |
| DartEntry entry = new DartEntry(); |
| Object value = entry.getValue(descriptor); |
| expect(newValue, isNot(same(value))); |
| entry.setValue(descriptor, newValue); |
| expect(entry.getState(descriptor), same(CacheState.VALID)); |
| expect(entry.getValue(descriptor), same(newValue)); |
| } |
| |
| void _setValueInLibrary(DataDescriptor descriptor, Object newValue) { |
| Source source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| Object value = entry.getValueInLibrary(descriptor, source); |
| expect(newValue, isNot(same(value))); |
| entry.setValueInLibrary(descriptor, source, newValue); |
| expect(entry.getStateInLibrary(descriptor, source), same(CacheState.VALID)); |
| expect(entry.getValueInLibrary(descriptor, source), same(newValue)); |
| } |
| } |
| |
| @reflectiveTest |
| class GenerateDartErrorsTaskTest extends EngineTestCase { |
| void test_accept() { |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(null, null, null, null); |
| expect(task.accept(new GenerateDartErrorsTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(null, null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getLibraryElement() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElement element = ElementFactory.library(context, "lib"); |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(context, null, null, element); |
| expect(task.libraryElement, same(element)); |
| } |
| |
| void test_getSource() { |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(null, source, null, null); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| context.applyChanges(changeSet); |
| context.setContents( |
| source, |
| r''' |
| library lib; |
| class A { |
| int f = new A(); |
| }'''); |
| LibraryElement libraryElement = context.computeLibraryElement(source); |
| CompilationUnit unit = |
| context.getResolvedCompilationUnit(source, libraryElement); |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(context, source, unit, libraryElement); |
| task.perform( |
| new GenerateDartErrorsTaskTestTV_perform(libraryElement, source)); |
| } |
| |
| void test_perform_validateDirectives() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| Source source = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| context.applyChanges(changeSet); |
| // TODO(scheglov) "import" causes second error reported |
| // context.setContents(source, EngineTestCase.createSource([ |
| // "library lib;", |
| // "import 'invaliduri^.dart';", |
| // "export '\${a}lib3.dart';", |
| // "part '/does/not/exist.dart';", |
| // "class A {}"])); |
| context.setContents( |
| source, |
| r''' |
| library lib; |
| part '/does/not/exist.dart'; |
| class A {}'''); |
| LibraryElement libraryElement = context.computeLibraryElement(source); |
| CompilationUnit unit = |
| context.getResolvedCompilationUnit(source, libraryElement); |
| GenerateDartErrorsTask task = |
| new GenerateDartErrorsTask(context, source, unit, libraryElement); |
| task.perform(new GenerateDartErrorsTaskTestTV_perform_validateDirectives( |
| libraryElement, source)); |
| } |
| } |
| |
| class GenerateDartErrorsTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => true; |
| } |
| |
| class GenerateDartErrorsTaskTestTV_perform extends TestTaskVisitor<bool> { |
| LibraryElement libraryElement; |
| Source source; |
| GenerateDartErrorsTaskTestTV_perform(this.libraryElement, this.source); |
| @override |
| bool visitGenerateDartErrorsTask(GenerateDartErrorsTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.libraryElement, same(libraryElement)); |
| expect(task.source, same(source)); |
| List<AnalysisError> errors = task.errors; |
| expect(errors, hasLength(1)); |
| return true; |
| } |
| } |
| |
| class GenerateDartErrorsTaskTestTV_perform_validateDirectives |
| extends TestTaskVisitor<bool> { |
| LibraryElement libraryElement; |
| Source source; |
| GenerateDartErrorsTaskTestTV_perform_validateDirectives( |
| this.libraryElement, this.source); |
| @override |
| bool visitGenerateDartErrorsTask(GenerateDartErrorsTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.libraryElement, same(libraryElement)); |
| expect(task.source, same(source)); |
| List<AnalysisError> errors = task.errors; |
| expect(errors, hasLength(1)); |
| expect(errors[0].errorCode, same(CompileTimeErrorCode.URI_DOES_NOT_EXIST)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class GenerateDartHintsTaskTest extends EngineTestCase { |
| void test_accept() { |
| GenerateDartHintsTask task = new GenerateDartHintsTask(null, null, null); |
| expect(task.accept(new GenerateDartHintsTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| GenerateDartHintsTask task = new GenerateDartHintsTask(null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getHintMap() { |
| GenerateDartHintsTask task = new GenerateDartHintsTask(null, null, null); |
| expect(task.hintMap, isNull); |
| } |
| |
| void test_getLibraryElement() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElement element = ElementFactory.library(context, "lib"); |
| GenerateDartHintsTask task = |
| new GenerateDartHintsTask(context, null, element); |
| expect(task.libraryElement, same(element)); |
| } |
| |
| void test_perform() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ChangeSet changeSet = new ChangeSet(); |
| Source librarySource = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| changeSet.addedSource(librarySource); |
| Source unusedSource = |
| new FileBasedSource(FileUtilities2.createFile("/unused.dart")); |
| changeSet.addedSource(unusedSource); |
| Source partSource = |
| new FileBasedSource(FileUtilities2.createFile("/part.dart")); |
| changeSet.addedSource(partSource); |
| context.applyChanges(changeSet); |
| context.setContents( |
| librarySource, |
| r''' |
| library lib; |
| import 'unused.dart'; |
| part 'part.dart';'''); |
| context.setContents(unusedSource, "library unused;"); |
| context.setContents(partSource, "part of lib;"); |
| List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(2); |
| units[0] = new TimestampedData<CompilationUnit>( |
| context.getModificationStamp(librarySource), |
| context.resolveCompilationUnit2(librarySource, librarySource)); |
| units[1] = new TimestampedData<CompilationUnit>( |
| context.getModificationStamp(partSource), |
| context.resolveCompilationUnit2(partSource, librarySource)); |
| GenerateDartHintsTask task = new GenerateDartHintsTask( |
| context, units, context.computeLibraryElement(librarySource)); |
| task.perform( |
| new GenerateDartHintsTaskTestTV_perform(librarySource, partSource)); |
| } |
| } |
| |
| class GenerateDartHintsTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitGenerateDartHintsTask(GenerateDartHintsTask task) => true; |
| } |
| |
| class GenerateDartHintsTaskTestTV_perform extends TestTaskVisitor<bool> { |
| Source librarySource; |
| Source partSource; |
| GenerateDartHintsTaskTestTV_perform(this.librarySource, this.partSource); |
| @override |
| bool visitGenerateDartHintsTask(GenerateDartHintsTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.libraryElement, isNotNull); |
| HashMap<Source, List<AnalysisError>> hintMap = task.hintMap; |
| expect(hintMap, hasLength(2)); |
| expect(hintMap[librarySource], hasLength(1)); |
| expect(hintMap[partSource], hasLength(0)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class GenerateDartLintsTaskTest extends EngineTestCase { |
| void test_accept() { |
| GenerateDartLintsTask task = new GenerateDartLintsTask(null, null, null); |
| expect(task.accept(new GenerateDartLintsTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_exception() { |
| GenerateDartLintsTask task = new GenerateDartLintsTask(null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_libraryElement() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElement element = ElementFactory.library(context, "lib"); |
| GenerateDartLintsTask task = |
| new GenerateDartLintsTask(context, null, element); |
| expect(task.libraryElement, same(element)); |
| } |
| |
| void test_lintMap() { |
| GenerateDartLintsTask task = new GenerateDartLintsTask(null, null, null); |
| expect(task.lintMap, isNull); |
| } |
| |
| void test_perform() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ChangeSet changeSet = new ChangeSet(); |
| Source librarySource = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| changeSet.addedSource(librarySource); |
| context.applyChanges(changeSet); |
| context.setContents( |
| librarySource, |
| r''' |
| library lib; |
| '''); |
| List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(1); |
| units[0] = new TimestampedData<CompilationUnit>( |
| context.getModificationStamp(librarySource), |
| context.resolveCompilationUnit2(librarySource, librarySource)); |
| GenerateDartLintsTask task = new GenerateDartLintsTask( |
| context, units, context.computeLibraryElement(librarySource)); |
| task.perform(new GenerateDartLintsTaskTestTV_perform(librarySource)); |
| } |
| } |
| |
| class GenerateDartLintsTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitGenerateDartLintsTask(GenerateDartLintsTask task) => true; |
| } |
| |
| class GenerateDartLintsTaskTestTV_perform extends TestTaskVisitor<bool> { |
| Source librarySource; |
| GenerateDartLintsTaskTestTV_perform(this.librarySource); |
| @override |
| bool visitGenerateDartLintsTask(GenerateDartLintsTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.libraryElement, isNotNull); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class GetContentTaskTest extends EngineTestCase { |
| void test_accept() { |
| Source source = new TestSource('/test.dart', ''); |
| GetContentTask task = new GetContentTask(null, source); |
| expect(task.accept(new GetContentTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| Source source = new TestSource('/test.dart', ''); |
| GetContentTask task = new GetContentTask(null, source); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getModificationTime() { |
| Source source = new TestSource('/test.dart', ''); |
| GetContentTask task = new GetContentTask(null, source); |
| expect(task.modificationTime, -1); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('/test.dart', ''); |
| GetContentTask task = new GetContentTask(null, source); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform_exception() { |
| TestSource source = new TestSource(); |
| source.generateExceptionOnRead = true; |
| // final InternalAnalysisContext context = new AnalysisContextImpl(); |
| // context.setSourceFactory(new SourceFactory(new FileUriResolver())); |
| GetContentTask task = new GetContentTask(null, source); |
| task.perform(new GetContentTaskTestTV_perform_exception()); |
| } |
| |
| void test_perform_valid() { |
| Source source = new TestSource('/test.dart', 'class A {}'); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| GetContentTask task = new GetContentTask(context, source); |
| task.perform(new GetContentTaskTestTV_perform_valid(context, source)); |
| } |
| } |
| |
| class GetContentTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitGetContentTask(GetContentTask task) => true; |
| } |
| |
| class GetContentTaskTestTV_perform_exception extends TestTaskVisitor<bool> { |
| @override |
| bool visitGetContentTask(GetContentTask task) { |
| expect(task.exception, isNotNull); |
| return true; |
| } |
| } |
| |
| class GetContentTaskTestTV_perform_valid extends TestTaskVisitor<bool> { |
| InternalAnalysisContext context; |
| Source source; |
| GetContentTaskTestTV_perform_valid(this.context, this.source); |
| @override |
| bool visitGetContentTask(GetContentTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.modificationTime, context.getModificationStamp(source)); |
| expect(task.source, same(source)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class HtmlEntryTest extends EngineTestCase { |
| void set state(DataDescriptor descriptor) { |
| HtmlEntry entry = new HtmlEntry(); |
| expect(entry.getState(descriptor), isNot(same(CacheState.FLUSHED))); |
| entry.setState(descriptor, CacheState.FLUSHED); |
| expect(entry.getState(descriptor), same(CacheState.FLUSHED)); |
| } |
| |
| void test_creation() { |
| HtmlEntry entry = new HtmlEntry(); |
| expect(entry, isNotNull); |
| } |
| |
| void test_getAllErrors() { |
| Source source = new TestSource(); |
| HtmlEntry entry = new HtmlEntry(); |
| expect(entry.allErrors, hasLength(0)); |
| entry.setValue(HtmlEntry.PARSE_ERRORS, <AnalysisError>[ |
| new AnalysisError(source, 0, 0, ParserErrorCode.EXPECTED_TOKEN, [";"]) |
| ]); |
| entry.setValue(HtmlEntry.RESOLUTION_ERRORS, <AnalysisError>[ |
| new AnalysisError(source, 0, 0, HtmlWarningCode.INVALID_URI, ["-"]) |
| ]); |
| entry.setValue(HtmlEntry.HINTS, |
| <AnalysisError>[new AnalysisError(source, 0, 0, HintCode.DEAD_CODE)]); |
| expect(entry.allErrors, hasLength(3)); |
| } |
| |
| void test_invalidateAllResolutionInformation() { |
| HtmlEntry entry = _entryWithValidState(); |
| entry.invalidateAllResolutionInformation(false); |
| expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.INVALID)); |
| expect(entry.getState(HtmlEntry.HINTS), same(CacheState.INVALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect( |
| entry.getState(HtmlEntry.REFERENCED_LIBRARIES), same(CacheState.VALID)); |
| expect( |
| entry.getState(HtmlEntry.RESOLUTION_ERRORS), same(CacheState.INVALID)); |
| } |
| |
| void test_invalidateAllResolutionInformation_includingUris() { |
| HtmlEntry entry = _entryWithValidState(); |
| entry.invalidateAllResolutionInformation(true); |
| expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.INVALID)); |
| expect(entry.getState(HtmlEntry.HINTS), same(CacheState.INVALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.REFERENCED_LIBRARIES), |
| same(CacheState.INVALID)); |
| expect( |
| entry.getState(HtmlEntry.RESOLUTION_ERRORS), same(CacheState.INVALID)); |
| } |
| |
| void test_setState_element() { |
| state = HtmlEntry.ELEMENT; |
| } |
| |
| void test_setState_hints() { |
| state = HtmlEntry.HINTS; |
| } |
| |
| void test_setState_lineInfo() { |
| state = SourceEntry.LINE_INFO; |
| } |
| |
| void test_setState_parsedUnit() { |
| state = HtmlEntry.PARSED_UNIT; |
| } |
| |
| void test_setState_parseErrors() { |
| state = HtmlEntry.PARSE_ERRORS; |
| } |
| |
| void test_setState_referencedLibraries() { |
| state = HtmlEntry.REFERENCED_LIBRARIES; |
| } |
| |
| void test_setState_resolutionErrors() { |
| state = HtmlEntry.RESOLUTION_ERRORS; |
| } |
| |
| void test_setValue_element() { |
| _setValue(HtmlEntry.ELEMENT, new HtmlElementImpl(null, "test.html")); |
| } |
| |
| void test_setValue_hints() { |
| _setValue(HtmlEntry.HINTS, |
| <AnalysisError>[new AnalysisError(null, 0, 0, HintCode.DEAD_CODE)]); |
| } |
| |
| void test_setValue_illegal() { |
| HtmlEntry entry = new HtmlEntry(); |
| try { |
| entry.setValue(DartEntry.ELEMENT, null); |
| fail("Expected ArgumentError for DartEntry.ELEMENT"); |
| } on ArgumentError {} |
| } |
| |
| void test_setValue_lineInfo() { |
| _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0])); |
| } |
| |
| void test_setValue_parsedUnit() { |
| _setValue(HtmlEntry.PARSED_UNIT, new ht.HtmlUnit(null, null, null)); |
| } |
| |
| void test_setValue_parseErrors() { |
| _setValue(HtmlEntry.PARSE_ERRORS, <AnalysisError>[ |
| new AnalysisError(null, 0, 0, HtmlWarningCode.INVALID_URI, ["-"]) |
| ]); |
| } |
| |
| void test_setValue_referencedLibraries() { |
| _setValue(HtmlEntry.REFERENCED_LIBRARIES, <Source>[new TestSource()]); |
| } |
| |
| void test_setValue_resolutionErrors() { |
| _setValue(HtmlEntry.RESOLUTION_ERRORS, <AnalysisError>[ |
| new AnalysisError(null, 0, 0, HtmlWarningCode.INVALID_URI, ["-"]) |
| ]); |
| } |
| |
| HtmlEntry _entryWithValidState() { |
| HtmlEntry entry = new HtmlEntry(); |
| 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.REFERENCED_LIBRARIES, null); |
| entry.setValue(HtmlEntry.RESOLUTION_ERRORS, null); |
| expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.HINTS), same(CacheState.VALID)); |
| expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.PARSED_UNIT), same(CacheState.VALID)); |
| expect( |
| entry.getState(HtmlEntry.REFERENCED_LIBRARIES), same(CacheState.VALID)); |
| expect(entry.getState(HtmlEntry.RESOLUTION_ERRORS), same(CacheState.VALID)); |
| return entry; |
| } |
| |
| void _setValue(DataDescriptor descriptor, Object newValue) { |
| HtmlEntry entry = new HtmlEntry(); |
| Object value = entry.getValue(descriptor); |
| expect(newValue, isNot(same(value))); |
| entry.setValue(descriptor, newValue); |
| expect(entry.getState(descriptor), same(CacheState.VALID)); |
| expect(entry.getValue(descriptor), same(newValue)); |
| } |
| } |
| |
| @reflectiveTest |
| class IncrementalAnalysisCacheTest { |
| Source _source = new TestSource(); |
| DartEntry _entry = new DartEntry(); |
| CompilationUnit _unit = new CompilationUnitMock(); |
| IncrementalAnalysisCache _result; |
| void setUp() { |
| _entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, _unit); |
| } |
| |
| void test_cacheResult() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| _result = IncrementalAnalysisCache.cacheResult(cache, newUnit); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(newUnit)); |
| expect(_result.oldContents, "hbazlo"); |
| expect(_result.newContents, "hbazlo"); |
| expect(_result.offset, 0); |
| expect(_result.oldLength, 0); |
| expect(_result.newLength, 0); |
| } |
| |
| void test_cacheResult_noCache() { |
| IncrementalAnalysisCache cache = null; |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| _result = IncrementalAnalysisCache.cacheResult(cache, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_cacheResult_noCacheNoResult() { |
| IncrementalAnalysisCache cache = null; |
| CompilationUnit newUnit = null; |
| _result = IncrementalAnalysisCache.cacheResult(cache, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_cacheResult_noResult() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| CompilationUnit newUnit = null; |
| _result = IncrementalAnalysisCache.cacheResult(cache, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_clear_differentSource() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| Source otherSource = new TestSource("blat.dart", "blat"); |
| _result = IncrementalAnalysisCache.clear(cache, otherSource); |
| expect(_result, same(cache)); |
| } |
| |
| void test_clear_nullCache() { |
| IncrementalAnalysisCache cache = null; |
| _result = IncrementalAnalysisCache.clear(cache, _source); |
| expect(_result, isNull); |
| } |
| |
| void test_clear_sameSource() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| _result = IncrementalAnalysisCache.clear(cache, _source); |
| expect(_result, isNull); |
| } |
| |
| void test_update_append() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbazxlo", 4, 0, 1, newEntry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hbazxlo"); |
| expect(_result.offset, 1); |
| expect(_result.oldLength, 2); |
| expect(_result.newLength, 4); |
| } |
| |
| void test_update_appendToCachedResult() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| cache = IncrementalAnalysisCache.cacheResult(cache, newUnit); |
| expect(cache, isNotNull); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbazxlo", 4, 0, 1, newEntry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(newUnit)); |
| expect(_result.oldContents, "hbazlo"); |
| expect(_result.newContents, "hbazxlo"); |
| expect(_result.offset, 4); |
| expect(_result.oldLength, 0); |
| expect(_result.newLength, 1); |
| } |
| |
| void test_update_appendWithNewResolvedUnit() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| newEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, newUnit); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbazxlo", 4, 0, 1, newEntry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(newUnit)); |
| expect(_result.oldContents, "hbazlo"); |
| expect(_result.newContents, "hbazxlo"); |
| expect(_result.offset, 4); |
| expect(_result.oldLength, 0); |
| expect(_result.newLength, 1); |
| } |
| |
| void test_update_appendWithNoNewResolvedUnit() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbazxlo", 4, 0, 1, newEntry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hbazxlo"); |
| expect(_result.offset, 1); |
| expect(_result.oldLength, 2); |
| expect(_result.newLength, 4); |
| } |
| |
| void test_update_delete() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hzlo", 1, 2, 0, newEntry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hzlo"); |
| expect(_result.offset, 1); |
| expect(_result.oldLength, 2); |
| expect(_result.newLength, 1); |
| } |
| |
| void test_update_insert_nonContiguous_after() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbazlox", 6, 0, 1, newEntry); |
| expect(_result, isNull); |
| } |
| |
| void test_update_insert_nonContiguous_before() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| DartEntry newEntry = new DartEntry(); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "xhbazlo", 0, 0, 1, newEntry); |
| expect(_result, isNull); |
| } |
| |
| void test_update_newSource_entry() { |
| Source oldSource = new TestSource("blat.dart", "blat"); |
| DartEntry oldEntry = new DartEntry(); |
| CompilationUnit oldUnit = new CompilationUnitMock(); |
| oldEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, oldUnit); |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, oldSource, "hello", "hbazlo", 1, 2, 3, oldEntry); |
| expect(cache.source, same(oldSource)); |
| expect(cache.resolvedUnit, same(oldUnit)); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "foo", "foobz", 3, 0, 2, _entry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "foo"); |
| expect(_result.newContents, "foobz"); |
| expect(_result.offset, 3); |
| expect(_result.oldLength, 0); |
| expect(_result.newLength, 2); |
| } |
| |
| void test_update_newSource_noEntry() { |
| Source oldSource = new TestSource("blat.dart", "blat"); |
| DartEntry oldEntry = new DartEntry(); |
| CompilationUnit oldUnit = new CompilationUnitMock(); |
| oldEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, oldUnit); |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, oldSource, "hello", "hbazlo", 1, 2, 3, oldEntry); |
| expect(cache.source, same(oldSource)); |
| expect(cache.resolvedUnit, same(oldUnit)); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "foo", "foobar", 3, 0, 3, null); |
| expect(_result, isNull); |
| } |
| |
| void test_update_noCache_entry() { |
| _result = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hbazlo"); |
| expect(_result.offset, 1); |
| expect(_result.oldLength, 2); |
| expect(_result.newLength, 3); |
| expect(_result.hasWork, isTrue); |
| } |
| |
| void test_update_noCache_entry_noOldSource_append() { |
| _result = IncrementalAnalysisCache.update( |
| null, _source, null, "hellxo", 4, 0, 1, _entry); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hellxo"); |
| expect(_result.offset, 4); |
| expect(_result.oldLength, 0); |
| expect(_result.newLength, 1); |
| expect(_result.hasWork, isTrue); |
| } |
| |
| void test_update_noCache_entry_noOldSource_delete() { |
| _result = IncrementalAnalysisCache.update( |
| null, _source, null, "helo", 4, 1, 0, _entry); |
| expect(_result, isNull); |
| } |
| |
| void test_update_noCache_entry_noOldSource_replace() { |
| _result = IncrementalAnalysisCache.update( |
| null, _source, null, "helxo", 4, 1, 1, _entry); |
| expect(_result, isNull); |
| } |
| |
| void test_update_noCache_noEntry() { |
| _result = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, null); |
| expect(_result, isNull); |
| } |
| |
| void test_update_replace() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| _result = IncrementalAnalysisCache.update( |
| cache, _source, "hbazlo", "hbarrlo", 3, 1, 2, null); |
| expect(_result, isNotNull); |
| expect(_result.source, same(_source)); |
| expect(_result.resolvedUnit, same(_unit)); |
| expect(_result.oldContents, "hello"); |
| expect(_result.newContents, "hbarrlo"); |
| expect(_result.offset, 1); |
| expect(_result.oldLength, 2); |
| expect(_result.newLength, 4); |
| } |
| |
| void test_verifyStructure_invalidUnit() { |
| String oldCode = "main() {foo;}"; |
| String newCode = "main() {boo;}"; |
| CompilationUnit badUnit = _parse("main() {bad;}"); |
| _entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, badUnit); |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, oldCode, newCode, 8, 1, 1, _entry); |
| CompilationUnit newUnit = _parse(newCode); |
| _result = IncrementalAnalysisCache.verifyStructure(cache, _source, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_verifyStructure_noCache() { |
| IncrementalAnalysisCache cache = null; |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| _result = IncrementalAnalysisCache.verifyStructure(cache, _source, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_verifyStructure_noCacheNoUnit() { |
| IncrementalAnalysisCache cache = null; |
| CompilationUnit newUnit = null; |
| _result = IncrementalAnalysisCache.verifyStructure(cache, _source, newUnit); |
| expect(_result, isNull); |
| } |
| |
| void test_verifyStructure_noUnit() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| CompilationUnit newUnit = null; |
| _result = IncrementalAnalysisCache.verifyStructure(cache, _source, newUnit); |
| expect(_result, same(cache)); |
| expect(_result.resolvedUnit, same(_unit)); |
| } |
| |
| void test_verifyStructure_otherSource() { |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, "hello", "hbazlo", 1, 2, 3, _entry); |
| CompilationUnit newUnit = new CompilationUnitMock(); |
| Source otherSource = new TestSource("blat.dart", "blat"); |
| _result = |
| IncrementalAnalysisCache.verifyStructure(cache, otherSource, newUnit); |
| expect(_result, same(cache)); |
| expect(_result.resolvedUnit, same(_unit)); |
| } |
| |
| void test_verifyStructure_validUnit() { |
| String oldCode = "main() {foo;}"; |
| String newCode = "main() {boo;}"; |
| CompilationUnit goodUnit = _parse(newCode); |
| _entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, _source, goodUnit); |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, _source, oldCode, newCode, 1, 2, 3, _entry); |
| CompilationUnit newUnit = _parse(newCode); |
| _result = IncrementalAnalysisCache.verifyStructure(cache, _source, newUnit); |
| expect(_result, same(cache)); |
| expect(_result.resolvedUnit, same(goodUnit)); |
| } |
| |
| CompilationUnit _parse(String code) { |
| Scanner scanner = new Scanner(_source, new CharSequenceReader(code), |
| AnalysisErrorListener.NULL_LISTENER); |
| Parser parser = new Parser(_source, AnalysisErrorListener.NULL_LISTENER); |
| return parser.parseCompilationUnit(scanner.tokenize()); |
| } |
| } |
| |
| @reflectiveTest |
| class IncrementalAnalysisTaskTest extends EngineTestCase { |
| void test_accept() { |
| IncrementalAnalysisTask task = new IncrementalAnalysisTask(null, null); |
| expect(task.accept(new IncrementalAnalysisTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_perform() { |
| // main() {} String foo; |
| // main() {String} String foo; |
| CompilationUnit newUnit = |
| _assertTask("main() {", "", "String", "} String foo;"); |
| NodeList<CompilationUnitMember> declarations = newUnit.declarations; |
| FunctionDeclaration main = declarations[0] as FunctionDeclaration; |
| expect(main.name.name, "main"); |
| BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody; |
| ExpressionStatement statement = |
| body.block.statements[0] as ExpressionStatement; |
| expect(statement.toSource(), "String;"); |
| SimpleIdentifier identifier = statement.expression as SimpleIdentifier; |
| expect(identifier.name, "String"); |
| expect(identifier.staticElement, isNotNull); |
| TopLevelVariableDeclaration fooDecl = |
| declarations[1] as TopLevelVariableDeclaration; |
| SimpleIdentifier fooName = fooDecl.variables.variables[0].name; |
| expect(fooName.name, "foo"); |
| expect(fooName.staticElement, isNotNull); |
| // assert element reference is preserved |
| } |
| |
| CompilationUnit _assertTask( |
| String prefix, String removed, String added, String suffix) { |
| String oldCode = "$prefix$removed$suffix"; |
| String newCode = "$prefix$added$suffix"; |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| Source source = new TestSource("/test.dart", oldCode); |
| DartEntry entry = new DartEntry(); |
| CompilationUnit oldUnit = context.resolveCompilationUnit2(source, source); |
| expect(oldUnit, isNotNull); |
| entry.setValueInLibrary(DartEntry.RESOLVED_UNIT, source, oldUnit); |
| IncrementalAnalysisCache cache = IncrementalAnalysisCache.update( |
| null, |
| source, |
| oldCode, |
| newCode, |
| prefix.length, |
| removed.length, |
| added.length, |
| entry); |
| expect(cache, isNotNull); |
| IncrementalAnalysisTask task = new IncrementalAnalysisTask(context, cache); |
| CompilationUnit newUnit = |
| task.perform(new IncrementalAnalysisTaskTestTV_assertTask(task)); |
| expect(newUnit, isNotNull); |
| return newUnit; |
| } |
| } |
| |
| class IncrementalAnalysisTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => true; |
| } |
| |
| class IncrementalAnalysisTaskTestTV_assertTask |
| extends TestTaskVisitor<CompilationUnit> { |
| IncrementalAnalysisTask task; |
| IncrementalAnalysisTaskTestTV_assertTask(this.task); |
| @override |
| CompilationUnit visitIncrementalAnalysisTask( |
| IncrementalAnalysisTask incrementalAnalysisTask) => |
| task.compilationUnit; |
| } |
| |
| @reflectiveTest |
| class LintGeneratorTest extends EngineTestCase { |
| void test_generate() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ChangeSet changeSet = new ChangeSet(); |
| Source librarySource = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| changeSet.addedSource(librarySource); |
| context.applyChanges(changeSet); |
| context.setContents( |
| librarySource, |
| r''' |
| library lib; |
| '''); |
| |
| CompilationUnit unit = |
| context.resolveCompilationUnit2(librarySource, librarySource); |
| List<CompilationUnit> units = <CompilationUnit>[]; |
| units.add(unit); |
| |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| |
| LintGeneratorTest_Linter linter = new LintGeneratorTest_Linter(); |
| |
| LintGenerator lintGenerator = |
| new LintGenerator(units, errorListener, [linter]); |
| lintGenerator.generate(); |
| |
| linter.testExpectations(); |
| } |
| |
| void test_generate_null_visitor() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ChangeSet changeSet = new ChangeSet(); |
| Source librarySource = |
| new FileBasedSource(FileUtilities2.createFile("/test.dart")); |
| changeSet.addedSource(librarySource); |
| context.applyChanges(changeSet); |
| context.setContents( |
| librarySource, |
| r''' |
| library lib; |
| '''); |
| |
| CompilationUnit unit = |
| context.resolveCompilationUnit2(librarySource, librarySource); |
| List<CompilationUnit> units = <CompilationUnit>[]; |
| units.add(unit); |
| |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| |
| Linter badLinter = new LintGeneratorTest_Linter_Null_Visitor(); |
| LintGeneratorTest_Linter goodLinter = new LintGeneratorTest_Linter(); |
| |
| LintGenerator lintGenerator = |
| new LintGenerator(units, errorListener, [badLinter, goodLinter]); |
| // Test that generate does not fall down with a null visitor |
| lintGenerator.generate(); |
| // Well-formed linter should still get called |
| goodLinter.testExpectations(); |
| } |
| } |
| |
| class LintGeneratorTest_Linter extends Linter with SimpleAstVisitor<Object> { |
| bool visited; |
| |
| @override |
| AstVisitor getVisitor() => this; |
| |
| testExpectations() { |
| expect(reporter, isNotNull); |
| expect(visited, isTrue); |
| } |
| |
| @override |
| Object visitCompilationUnit(CompilationUnit node) { |
| visited = true; |
| return null; |
| } |
| } |
| |
| class LintGeneratorTest_Linter_Null_Visitor extends Linter { |
| @override |
| AstVisitor getVisitor() => null; |
| } |
| |
| class MockSourceFactory extends SourceFactory { |
| MockSourceFactory() : super([]); |
| Source resolveUri(Source containingSource, String containedUri) { |
| throw new JavaIOException(); |
| } |
| } |
| |
| @reflectiveTest |
| class ParseDartTaskTest extends EngineTestCase { |
| void test_accept() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.accept(new ParseDartTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getCompilationUnit() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.compilationUnit, isNull); |
| } |
| |
| void test_getErrors() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.errors, hasLength(0)); |
| } |
| |
| void test_getException() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('/test.dart'); |
| ParseDartTask task = new ParseDartTask(null, source, null, null); |
| expect(task.source, same(source)); |
| } |
| |
| void test_hasNonPartOfDirective() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.hasNonPartOfDirective, isFalse); |
| } |
| |
| void test_hasPartOfDirective() { |
| ParseDartTask task = new ParseDartTask(null, null, null, null); |
| expect(task.hasPartOfDirective, isFalse); |
| } |
| |
| void test_perform_exception() { |
| TestSource source = new TestSource(); |
| source.generateExceptionOnRead = true; |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ParseDartTask task = new ParseDartTask(context, source, null, null); |
| task.perform(new ParseDartTaskTestTV_perform_exception()); |
| } |
| |
| void test_perform_library() { |
| String content = r''' |
| library lib; |
| import 'lib2.dart'; |
| export 'lib3.dart'; |
| part 'part.dart'; |
| class A {'''; |
| Source source = new TestSource('/test.dart', content); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ParseDartTask task = _createParseTask(context, source, content); |
| task.perform(new ParseDartTaskTestTV_perform_library(context, source)); |
| } |
| |
| void test_perform_part() { |
| String content = r''' |
| part of lib; |
| class B {}'''; |
| Source source = new TestSource('/test.dart', content); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ParseDartTask task = _createParseTask(context, source, content); |
| task.perform(new ParseDartTaskTestTV_perform_part(context, source)); |
| } |
| |
| void test_perform_validateDirectives() { |
| String content = r''' |
| library lib; |
| import '/does/not/exist.dart'; |
| import '://invaliduri.dart'; |
| export '${a}lib3.dart'; |
| part 'part.dart'; |
| class A {}'''; |
| Source source = new TestSource('/test.dart', content); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ParseDartTask task = _createParseTask(context, source, content); |
| task.perform( |
| new ParseDartTaskTestTV_perform_validateDirectives(context, source)); |
| } |
| |
| void test_resolveDirective_dartUri() { |
| GatheringErrorListener listener = new GatheringErrorListener(); |
| ImportDirective directive = AstFactory.importDirective3('dart:core', null); |
| AnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| Source source = |
| ParseDartTask.resolveDirective(context, null, directive, listener); |
| expect(source, isNotNull); |
| } |
| |
| void test_resolveDirective_exception() { |
| GatheringErrorListener listener = new GatheringErrorListener(); |
| ImportDirective directive = AstFactory.importDirective3('dart:core', null); |
| AnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| context.sourceFactory = new MockSourceFactory(); |
| Source source = |
| ParseDartTask.resolveDirective(context, null, directive, listener); |
| expect(source, isNull); |
| expect(listener.errors, hasLength(1)); |
| } |
| |
| /** |
| * Create and return a task that will parse the given content from the given source in the given |
| * context. |
| * |
| * @param context the context to be passed to the task |
| * @param source the source to be parsed |
| * @param content the content of the source to be parsed |
| * @return the task that was created |
| * @throws AnalysisException if the task could not be created |
| */ |
| ParseDartTask _createParseTask( |
| InternalAnalysisContext context, Source source, String content) { |
| ScanDartTask scanTask = new ScanDartTask(context, source, content); |
| scanTask.perform(new ParseDartTaskTestTV_createParseTask()); |
| return new ParseDartTask( |
| context, source, scanTask.tokenStream, scanTask.lineInfo); |
| } |
| } |
| |
| class ParseDartTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitParseDartTask(ParseDartTask task) => true; |
| } |
| |
| class ParseDartTaskTestTV_createParseTask extends TestTaskVisitor<Object> { |
| @override |
| Object visitScanDartTask(ScanDartTask task) => null; |
| } |
| |
| class ParseDartTaskTestTV_perform_exception extends TestTaskVisitor<bool> { |
| @override |
| bool visitParseDartTask(ParseDartTask task) { |
| expect(task.exception, isNotNull); |
| return true; |
| } |
| } |
| |
| class ParseDartTaskTestTV_perform_library extends TestTaskVisitor<Object> { |
| InternalAnalysisContext context; |
| Source source; |
| ParseDartTaskTestTV_perform_library(this.context, this.source); |
| @override |
| Object visitParseDartTask(ParseDartTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.compilationUnit, isNotNull); |
| expect(task.errors, hasLength(1)); |
| expect(task.source, same(source)); |
| expect(task.hasNonPartOfDirective, isTrue); |
| expect(task.hasPartOfDirective, isFalse); |
| return null; |
| } |
| } |
| |
| class ParseDartTaskTestTV_perform_part extends TestTaskVisitor<Object> { |
| InternalAnalysisContext context; |
| Source source; |
| ParseDartTaskTestTV_perform_part(this.context, this.source); |
| @override |
| Object visitParseDartTask(ParseDartTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.compilationUnit, isNotNull); |
| expect(task.errors, hasLength(0)); |
| expect(task.source, same(source)); |
| expect(task.hasNonPartOfDirective, isFalse); |
| expect(task.hasPartOfDirective, isTrue); |
| return null; |
| } |
| } |
| |
| class ParseDartTaskTestTV_perform_validateDirectives |
| extends TestTaskVisitor<Object> { |
| InternalAnalysisContext context; |
| Source source; |
| ParseDartTaskTestTV_perform_validateDirectives(this.context, this.source); |
| @override |
| Object visitParseDartTask(ParseDartTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.compilationUnit, isNotNull); |
| GatheringErrorListener errorListener = new GatheringErrorListener(); |
| errorListener.addAll(task.errors); |
| errorListener.assertErrorsWithCodes([ |
| CompileTimeErrorCode.URI_WITH_INTERPOLATION, |
| CompileTimeErrorCode.INVALID_URI |
| ]); |
| expect(task.source, same(source)); |
| expect(task.hasNonPartOfDirective, isTrue); |
| expect(task.hasPartOfDirective, isFalse); |
| return null; |
| } |
| } |
| |
| @reflectiveTest |
| class ParseHtmlTaskTest extends EngineTestCase { |
| ParseHtmlTask parseContents(String contents, TestLogger testLogger) { |
| return parseSource( |
| new TestSource('/test.dart', contents), contents, testLogger); |
| } |
| |
| ParseHtmlTask parseSource( |
| Source source, String contents, TestLogger testLogger) { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| context.setContents(source, contents); |
| ParseHtmlTask task = new ParseHtmlTask(context, source, contents); |
| Logger oldLogger = AnalysisEngine.instance.logger; |
| try { |
| AnalysisEngine.instance.logger = testLogger; |
| task.perform(new ParseHtmlTaskTestTV_parseSource(context, source)); |
| } finally { |
| AnalysisEngine.instance.logger = oldLogger; |
| } |
| return task; |
| } |
| |
| void test_accept() { |
| ParseHtmlTask task = new ParseHtmlTask(null, null, ""); |
| expect(task.accept(new ParseHtmlTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| ParseHtmlTask task = new ParseHtmlTask(null, null, ""); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getHtmlUnit() { |
| ParseHtmlTask task = new ParseHtmlTask(null, null, ""); |
| expect(task.htmlUnit, isNull); |
| } |
| |
| void test_getLineInfo() { |
| ParseHtmlTask task = new ParseHtmlTask(null, null, ""); |
| expect(task.lineInfo, isNull); |
| } |
| |
| void test_getReferencedLibraries() { |
| ParseHtmlTask task = new ParseHtmlTask(null, null, ""); |
| expect(task.referencedLibraries, hasLength(0)); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('/test.dart'); |
| ParseHtmlTask task = new ParseHtmlTask(null, source, ""); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform_embedded_source() { |
| String contents = r''' |
| <html> |
| <head> |
| <script type='application/dart'> |
| void buttonPressed() {} |
| </script> |
| </head> |
| <body> |
| </body> |
| </html>'''; |
| TestLogger testLogger = new TestLogger(); |
| ParseHtmlTask task = parseContents(contents, testLogger); |
| expect(task.referencedLibraries, hasLength(0)); |
| expect(testLogger.errorCount, 0); |
| expect(testLogger.infoCount, 0); |
| } |
| |
| void test_perform_empty_source_reference() { |
| String contents = r''' |
| <html> |
| <head> |
| <script type='application/dart' src=''/> |
| </head> |
| <body> |
| </body> |
| </html>'''; |
| TestLogger testLogger = new TestLogger(); |
| ParseHtmlTask task = parseContents(contents, testLogger); |
| expect(task.referencedLibraries, hasLength(0)); |
| expect(testLogger.errorCount, 0); |
| expect(testLogger.infoCount, 0); |
| } |
| |
| void test_perform_invalid_source_reference() { |
| String contents = r''' |
| <html> |
| <head> |
| <script type='application/dart' src='an;invalid:[]uri'/> |
| </head> |
| <body> |
| </body> |
| </html>'''; |
| TestLogger testLogger = new TestLogger(); |
| ParseHtmlTask task = parseContents(contents, testLogger); |
| expect(task.referencedLibraries, hasLength(0)); |
| expect(testLogger.errorCount, 0); |
| expect(testLogger.infoCount, 0); |
| } |
| |
| void test_perform_non_existing_source_reference() { |
| String contents = r''' |
| <html> |
| <head> |
| <script type='application/dart' src='does/not/exist.dart'/> |
| </head> |
| <body> |
| </body> |
| </html>'''; |
| TestLogger testLogger = new TestLogger(); |
| ParseHtmlTask task = parseSource( |
| new ParseHtmlTaskTest_non_existing_source(contents), |
| contents, |
| testLogger); |
| expect(task.referencedLibraries, hasLength(0)); |
| expect(testLogger.errorCount, 0); |
| expect(testLogger.infoCount, 0); |
| } |
| |
| void test_perform_referenced_source() { |
| // TODO(scheglov) this test fails because we put into cache TestSource |
| // test.dart (and actually should test.html), but resolve |
| // src='test.dart' as a FileBasedSource |
| // We need to switch to a virtual file system and use it everywhere. |
| // String contents = EngineTestCase.createSource([ |
| // "<html>", |
| // "<head>", |
| // " <script type='application/dart' src='test.dart'/>", |
| // "</head>", |
| // "<body>", |
| // "</body>", |
| // "</html>"]); |
| // TestLogger testLogger = new TestLogger(); |
| // ParseHtmlTask task = parseContents(contents, testLogger); |
| // EngineTestCase.assertLength(1, task.referencedLibraries); |
| // JUnitTestCase.assertEquals(0, testLogger.errorCount); |
| // JUnitTestCase.assertEquals(0, testLogger.errorCount); |
| } |
| } |
| |
| class ParseHtmlTaskTest_non_existing_source extends TestSource { |
| ParseHtmlTaskTest_non_existing_source(String arg0) : super(arg0); |
| @override |
| Uri resolveRelativeUri(Uri containedUri) { |
| try { |
| return parseUriWithException("file:/does/not/exist.dart"); |
| } on URISyntaxException { |
| return null; |
| } |
| } |
| } |
| |
| class ParseHtmlTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitParseHtmlTask(ParseHtmlTask task) => true; |
| } |
| |
| class ParseHtmlTaskTestTV_parseSource extends TestTaskVisitor<bool> { |
| InternalAnalysisContext context; |
| Source source; |
| ParseHtmlTaskTestTV_parseSource(this.context, this.source); |
| @override |
| bool visitParseHtmlTask(ParseHtmlTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.htmlUnit, isNotNull); |
| expect(task.lineInfo, isNotNull); |
| expect(task.source, same(source)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class PartitionManagerTest extends EngineTestCase { |
| void test_clearCache() { |
| PartitionManager manager = new PartitionManager(); |
| DartSdk sdk = new MockDartSdk(); |
| SdkCachePartition oldPartition = manager.forSdk(sdk); |
| manager.clearCache(); |
| SdkCachePartition newPartition = manager.forSdk(sdk); |
| expect(newPartition, isNot(same(oldPartition))); |
| } |
| |
| void test_creation() { |
| expect(new PartitionManager(), isNotNull); |
| } |
| |
| void test_forSdk() { |
| PartitionManager manager = new PartitionManager(); |
| DartSdk sdk1 = new MockDartSdk(); |
| SdkCachePartition partition1 = manager.forSdk(sdk1); |
| expect(partition1, isNotNull); |
| expect(manager.forSdk(sdk1), same(partition1)); |
| DartSdk sdk2 = new MockDartSdk(); |
| SdkCachePartition partition2 = manager.forSdk(sdk2); |
| expect(partition2, isNotNull); |
| expect(manager.forSdk(sdk2), same(partition2)); |
| expect(partition2, isNot(same(partition1))); |
| } |
| } |
| |
| @reflectiveTest |
| class ResolveDartLibraryTaskTest extends EngineTestCase { |
| void test_accept() { |
| ResolveDartLibraryTask task = new ResolveDartLibraryTask(null, null, null); |
| expect(task.accept(new ResolveDartLibraryTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| ResolveDartLibraryTask task = new ResolveDartLibraryTask(null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getLibraryResolver() { |
| ResolveDartLibraryTask task = new ResolveDartLibraryTask(null, null, null); |
| expect(task.libraryResolver, isNull); |
| } |
| |
| void test_getLibrarySource() { |
| Source source = new TestSource('/test.dart'); |
| ResolveDartLibraryTask task = |
| new ResolveDartLibraryTask(null, null, source); |
| expect(task.librarySource, same(source)); |
| } |
| |
| void test_getUnitSource() { |
| Source source = new TestSource('/test.dart'); |
| ResolveDartLibraryTask task = |
| new ResolveDartLibraryTask(null, source, null); |
| expect(task.unitSource, same(source)); |
| } |
| |
| void test_perform_exception() { |
| TestSource source = new TestSource(); |
| source.generateExceptionOnRead = true; |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ResolveDartLibraryTask task = |
| new ResolveDartLibraryTask(context, source, source); |
| task.perform(new ResolveDartLibraryTaskTestTV_perform_exception()); |
| } |
| |
| void test_perform_library() { |
| Source source = new TestSource( |
| '/test.dart', |
| r''' |
| library lib; |
| class A {}'''); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ResolveDartLibraryTask task = |
| new ResolveDartLibraryTask(context, source, source); |
| task.perform(new ResolveDartLibraryTaskTestTV_perform_library(source)); |
| } |
| } |
| |
| class ResolveDartLibraryTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveDartLibraryTask(ResolveDartLibraryTask task) => true; |
| } |
| |
| class ResolveDartLibraryTaskTestTV_perform_exception |
| extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveDartLibraryTask(ResolveDartLibraryTask task) { |
| expect(task.exception, isNotNull); |
| return true; |
| } |
| } |
| |
| class ResolveDartLibraryTaskTestTV_perform_library |
| extends TestTaskVisitor<bool> { |
| Source source; |
| ResolveDartLibraryTaskTestTV_perform_library(this.source); |
| @override |
| bool visitResolveDartLibraryTask(ResolveDartLibraryTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.libraryResolver, isNotNull); |
| expect(task.librarySource, same(source)); |
| expect(task.unitSource, same(source)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class ResolveDartUnitTaskTest extends EngineTestCase { |
| void test_accept() { |
| ResolveDartUnitTask task = new ResolveDartUnitTask(null, null, null); |
| expect(task.accept(new ResolveDartUnitTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getException() { |
| ResolveDartUnitTask task = new ResolveDartUnitTask(null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getLibrarySource() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElementImpl element = ElementFactory.library(context, "lib"); |
| Source source = element.source; |
| ResolveDartUnitTask task = new ResolveDartUnitTask(null, null, element); |
| expect(task.librarySource, same(source)); |
| } |
| |
| void test_getResolvedUnit() { |
| ResolveDartUnitTask task = new ResolveDartUnitTask(null, null, null); |
| expect(task.resolvedUnit, isNull); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('/test.dart'); |
| ResolveDartUnitTask task = new ResolveDartUnitTask(null, source, null); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform_exception() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElementImpl element = ElementFactory.library(context, "lib"); |
| TestSource source = new TestSource(); |
| source.generateExceptionOnRead = true; |
| (element.definingCompilationUnit as CompilationUnitElementImpl).source = |
| source; |
| ResolveDartUnitTask task = |
| new ResolveDartUnitTask(context, source, element); |
| task.perform(new ResolveDartUnitTaskTestTV_perform_exception()); |
| } |
| |
| void test_perform_library() { |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| LibraryElementImpl libraryElement = ElementFactory.library(context, "lib"); |
| CompilationUnitElementImpl unitElement = |
| libraryElement.definingCompilationUnit as CompilationUnitElementImpl; |
| ClassElementImpl classElement = ElementFactory.classElement2("A"); |
| classElement.nameOffset = 19; |
| ConstructorElementImpl constructorElement = |
| ElementFactory.constructorElement2(classElement, null); |
| constructorElement.synthetic = true; |
| classElement.constructors = <ConstructorElement>[constructorElement]; |
| unitElement.types = <ClassElement>[classElement]; |
| Source source = unitElement.source; |
| context.setContents( |
| source, |
| r''' |
| library lib; |
| class A {}'''); |
| ResolveDartUnitTask task = |
| new ResolveDartUnitTask(context, source, libraryElement); |
| task.perform( |
| new ResolveDartUnitTaskTestTV_perform_library(source, context)); |
| } |
| } |
| |
| class ResolveDartUnitTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveDartUnitTask(ResolveDartUnitTask task) => true; |
| } |
| |
| class ResolveDartUnitTaskTestTV_perform_exception |
| extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveDartUnitTask(ResolveDartUnitTask task) { |
| expect(task.exception, isNotNull); |
| return true; |
| } |
| } |
| |
| class ResolveDartUnitTaskTestTV_perform_library extends TestTaskVisitor<bool> { |
| Source source; |
| InternalAnalysisContext context; |
| ResolveDartUnitTaskTestTV_perform_library(this.source, this.context); |
| @override |
| bool visitResolveDartUnitTask(ResolveDartUnitTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.librarySource, same(source)); |
| expect(task.resolvedUnit, isNotNull); |
| expect(task.source, same(source)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class ResolveHtmlTaskTest extends EngineTestCase { |
| void test_accept() { |
| ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null); |
| expect(task.accept(new ResolveHtmlTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getElement() { |
| ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null); |
| expect(task.element, isNull); |
| } |
| |
| void test_getException() { |
| ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getResolutionErrors() { |
| ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null); |
| expect(task.resolutionErrors, hasLength(0)); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('test.dart', ''); |
| ResolveHtmlTask task = new ResolveHtmlTask(null, source, 0, null); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform_exception() { |
| Source source = new TestSource(); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ResolveHtmlTask task = new ResolveHtmlTask(context, source, 0, null); |
| task.perform(new ResolveHtmlTaskTestTV_perform_exception()); |
| } |
| |
| void test_perform_valid() { |
| int modificationStamp = 73; |
| String content = r''' |
| <html> |
| <head> |
| <script type='application/dart'> |
| void f() { x = 0; } |
| </script> |
| </head> |
| <body> |
| </body> |
| </html>'''; |
| Source source = new TestSource("/test.html", content); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ParseHtmlTask parseTask = new ParseHtmlTask(context, source, content); |
| parseTask.perform(new ResolveHtmlTaskTestTV_perform_valid_2()); |
| ResolveHtmlTask task = new ResolveHtmlTask( |
| context, source, modificationStamp, parseTask.htmlUnit); |
| task.perform( |
| new ResolveHtmlTaskTestTV_perform_valid(modificationStamp, source)); |
| } |
| } |
| |
| class ResolveHtmlTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveHtmlTask(ResolveHtmlTask task) => true; |
| } |
| |
| class ResolveHtmlTaskTestTV_perform_exception extends TestTaskVisitor<bool> { |
| @override |
| bool visitResolveHtmlTask(ResolveHtmlTask task) { |
| expect(task.exception, isNotNull); |
| return true; |
| } |
| } |
| |
| class ResolveHtmlTaskTestTV_perform_valid extends TestTaskVisitor<Object> { |
| int modificationStamp; |
| Source source; |
| ResolveHtmlTaskTestTV_perform_valid(this.modificationStamp, this.source); |
| @override |
| Object visitResolveHtmlTask(ResolveHtmlTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.element, isNotNull); |
| expect(task.resolutionErrors, hasLength(1)); |
| expect(task.source, same(source)); |
| return null; |
| } |
| } |
| |
| class ResolveHtmlTaskTestTV_perform_valid_2 extends TestTaskVisitor<Object> { |
| @override |
| Object visitParseHtmlTask(ParseHtmlTask task) => null; |
| } |
| |
| @reflectiveTest |
| class ScanDartTaskTest extends EngineTestCase { |
| void test_accept() { |
| ScanDartTask task = new ScanDartTask(null, null, null); |
| expect(task.accept(new ScanDartTaskTestTV_accept()), isTrue); |
| } |
| |
| void test_getErrors() { |
| ScanDartTask task = new ScanDartTask(null, null, null); |
| expect(task.errors, hasLength(0)); |
| } |
| |
| void test_getException() { |
| ScanDartTask task = new ScanDartTask(null, null, null); |
| expect(task.exception, isNull); |
| } |
| |
| void test_getLineInfo() { |
| ScanDartTask task = new ScanDartTask(null, null, null); |
| expect(task.lineInfo, isNull); |
| } |
| |
| void test_getSource() { |
| Source source = new TestSource('test.dart', ''); |
| ScanDartTask task = new ScanDartTask(null, source, null); |
| expect(task.source, same(source)); |
| } |
| |
| void test_perform_valid() { |
| String content = 'class A {}'; |
| Source source = new TestSource('test.dart', content); |
| InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(); |
| ScanDartTask task = new ScanDartTask(context, source, content); |
| task.perform(new ScanDartTaskTestTV_perform_valid(context, source)); |
| } |
| } |
| |
| class ScanDartTaskTestTV_accept extends TestTaskVisitor<bool> { |
| @override |
| bool visitScanDartTask(ScanDartTask task) => true; |
| } |
| |
| class ScanDartTaskTestTV_perform_valid extends TestTaskVisitor<bool> { |
| InternalAnalysisContext context; |
| Source source; |
| ScanDartTaskTestTV_perform_valid(this.context, this.source); |
| @override |
| bool visitScanDartTask(ScanDartTask task) { |
| CaughtException exception = task.exception; |
| if (exception != null) { |
| throw exception; |
| } |
| expect(task.tokenStream, isNotNull); |
| expect(task.errors, hasLength(0)); |
| expect(task.lineInfo, isNotNull); |
| expect(task.source, same(source)); |
| return true; |
| } |
| } |
| |
| @reflectiveTest |
| class SdkCachePartitionTest extends EngineTestCase { |
| void test_contains_false() { |
| SdkCachePartition partition = new SdkCachePartition(null, 8); |
| Source source = new TestSource(); |
| expect(partition.contains(source), isFalse); |
| } |
| |
| void test_contains_true() { |
| SdkCachePartition partition = new SdkCachePartition(null, 8); |
| SourceFactory factory = new SourceFactory( |
| [new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]); |
| Source source = factory.forUri("dart:core"); |
| expect(partition.contains(source), isTrue); |
| } |
| |
| void test_creation() { |
| expect(new SdkCachePartition(null, 8), isNotNull); |
| } |
| } |
| |
| @reflectiveTest |
| class SourcesChangedEventTest { |
| void test_added() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.addedSource(source); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, wereSourcesAdded: true); |
| } |
| |
| void test_changedContent() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.changedContent(source, 'library A;'); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, changedSources: [source]); |
| } |
| |
| void test_changedContent2() { |
| var source = new StringSource('', '/test.dart'); |
| var event = new SourcesChangedEvent.changedContent(source, 'library A;'); |
| assertEvent(event, changedSources: [source]); |
| } |
| |
| void test_changedRange() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.changedRange(source, 'library A;', 0, 0, 13); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, changedSources: [source]); |
| } |
| |
| void test_changedRange2() { |
| var source = new StringSource('', '/test.dart'); |
| var event = |
| new SourcesChangedEvent.changedRange(source, 'library A;', 0, 0, 13); |
| assertEvent(event, changedSources: [source]); |
| } |
| |
| void test_changedSources() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.changedSource(source); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, changedSources: [source]); |
| } |
| |
| void test_deleted() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.deletedSource(source); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, wereSourcesRemovedOrDeleted: true); |
| } |
| |
| void test_empty() { |
| var changeSet = new ChangeSet(); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event); |
| } |
| |
| void test_removed() { |
| var source = new StringSource('', '/test.dart'); |
| var changeSet = new ChangeSet(); |
| changeSet.removedSource(source); |
| var event = new SourcesChangedEvent(changeSet); |
| assertEvent(event, wereSourcesRemovedOrDeleted: true); |
| } |
| |
| static void assertEvent(SourcesChangedEvent event, |
| {bool wereSourcesAdded: false, |
| List<Source> changedSources: Source.EMPTY_LIST, |
| bool wereSourcesRemovedOrDeleted: false}) { |
| expect(event.wereSourcesAdded, wereSourcesAdded); |
| expect(event.changedSources, changedSources); |
| expect(event.wereSourcesRemovedOrDeleted, wereSourcesRemovedOrDeleted); |
| } |
| } |
| |
| class SourcesChangedListener { |
| List<SourcesChangedEvent> actualEvents = []; |
| |
| void assertEvent( |
| {bool wereSourcesAdded: false, |
| List<Source> changedSources: Source.EMPTY_LIST, |
| bool wereSourcesRemovedOrDeleted: false}) { |
| if (actualEvents.isEmpty) { |
| fail('Expected event but found none'); |
| } |
| SourcesChangedEvent actual = actualEvents.removeAt(0); |
| SourcesChangedEventTest.assertEvent(actual, |
| wereSourcesAdded: wereSourcesAdded, |
| changedSources: changedSources, |
| wereSourcesRemovedOrDeleted: wereSourcesRemovedOrDeleted); |
| } |
| |
| void assertNoMoreEvents() { |
| expect(actualEvents, []); |
| } |
| |
| void onData(SourcesChangedEvent event) { |
| actualEvents.add(event); |
| } |
| } |
| |
| /** |
| * Instances of the class `TestAnalysisContext` implement an analysis context in which every |
| * method will cause a test to fail when invoked. |
| */ |
| class TestAnalysisContext implements InternalAnalysisContext { |
| @override |
| AnalysisCache get analysisCache { |
| fail("Unexpected invocation of analysisCache"); |
| return null; |
| } |
| |
| @override |
| AnalysisOptions get analysisOptions { |
| fail("Unexpected invocation of getAnalysisOptions"); |
| return null; |
| } |
| |
| @override |
| void set analysisOptions(AnalysisOptions options) { |
| fail("Unexpected invocation of setAnalysisOptions"); |
| } |
| |
| @override |
| void set analysisPriorityOrder(List<Source> sources) { |
| fail("Unexpected invocation of setAnalysisPriorityOrder"); |
| } |
| |
| @override |
| set contentCache(ContentCache value) { |
| fail("Unexpected invocation of setContentCache"); |
| } |
| |
| @override |
| DeclaredVariables get declaredVariables { |
| fail("Unexpected invocation of getDeclaredVariables"); |
| return null; |
| } |
| |
| @override |
| List<AnalysisTarget> get explicitTargets { |
| fail("Unexpected invocation of visitCacheItems"); |
| return null; |
| } |
| |
| @override |
| List<Source> get htmlSources { |
| fail("Unexpected invocation of getHtmlSources"); |
| return null; |
| } |
| |
| @override |
| Stream<ImplicitAnalysisEvent> get implicitAnalysisEvents { |
| fail("Unexpected invocation of analyzedSources"); |
| return null; |
| } |
| |
| @override |
| bool get isDisposed { |
| fail("Unexpected invocation of isDisposed"); |
| return false; |
| } |
| |
| @override |
| List<Source> get launchableClientLibrarySources { |
| fail("Unexpected invocation of getLaunchableClientLibrarySources"); |
| return null; |
| } |
| |
| @override |
| List<Source> get launchableServerLibrarySources { |
| fail("Unexpected invocation of getLaunchableServerLibrarySources"); |
| return null; |
| } |
| |
| @override |
| LibraryResolverFactory get libraryResolverFactory { |
| fail("Unexpected invocation of getLibraryResolverFactory"); |
| return null; |
| } |
| |
| @override |
| List<Source> get librarySources { |
| fail("Unexpected invocation of getLibrarySources"); |
| return null; |
| } |
| |
| @override |
| String get name { |
| fail("Unexpected invocation of name"); |
| return null; |
| } |
| |
| @override |
| set name(String value) { |
| fail("Unexpected invocation of name"); |
| } |
| |
| @override |
| Stream<SourcesChangedEvent> get onSourcesChanged { |
| fail("Unexpected invocation of onSourcesChanged"); |
| return null; |
| } |
| |
| @override |
| List<Source> get prioritySources { |
| fail("Unexpected invocation of getPrioritySources"); |
| return null; |
| } |
| |
| @override |
| List<AnalysisTarget> get priorityTargets { |
| fail("Unexpected invocation of visitCacheItems"); |
| return null; |
| } |
| |
| @override |
| CachePartition get privateAnalysisCachePartition { |
| fail("Unexpected invocation of privateAnalysisCachePartition"); |
| return null; |
| } |
| |
| @override |
| ResolverVisitorFactory get resolverVisitorFactory { |
| fail("Unexpected invocation of getResolverVisitorFactory"); |
| return null; |
| } |
| |
| @override |
| SourceFactory get sourceFactory { |
| fail("Unexpected invocation of getSourceFactory"); |
| return null; |
| } |
| |
| @override |
| void set sourceFactory(SourceFactory factory) { |
| fail("Unexpected invocation of setSourceFactory"); |
| } |
| |
| @override |
| List<Source> get sources { |
| fail("Unexpected invocation of sources"); |
| return null; |
| } |
| |
| @override |
| AnalysisContextStatistics get statistics { |
| fail("Unexpected invocation of getStatistics"); |
| return null; |
| } |
| |
| @override |
| TypeProvider get typeProvider { |
| fail("Unexpected invocation of getTypeProvider"); |
| return null; |
| } |
| |
| @override |
| void set typeProvider(TypeProvider typeProvider) { |
| fail("Unexpected invocation of set typeProvider"); |
| } |
| |
| @override |
| TypeSystem get typeSystem { |
| fail("Unexpected invocation of getTypeSystem"); |
| return null; |
| } |
| |
| @override |
| TypeResolverVisitorFactory get typeResolverVisitorFactory { |
| fail("Unexpected invocation of getTypeResolverVisitorFactory"); |
| return null; |
| } |
| |
| @override |
| void addListener(AnalysisListener listener) { |
| fail("Unexpected invocation of addListener"); |
| } |
| |
| @override |
| void applyAnalysisDelta(AnalysisDelta delta) { |
| fail("Unexpected invocation of applyAnalysisDelta"); |
| } |
| |
| @override |
| void applyChanges(ChangeSet changeSet) { |
| fail("Unexpected invocation of applyChanges"); |
| } |
| |
| @override |
| String computeDocumentationComment(Element element) { |
| fail("Unexpected invocation of computeDocumentationComment"); |
| return null; |
| } |
| |
| @override |
| List<AnalysisError> computeErrors(Source source) { |
| fail("Unexpected invocation of computeErrors"); |
| return null; |
| } |
| |
| @override |
| List<Source> computeExportedLibraries(Source source) { |
| fail("Unexpected invocation of computeExportedLibraries"); |
| return null; |
| } |
| |
| @override |
| @deprecated |
| HtmlElement computeHtmlElement(Source source) { |
| fail("Unexpected invocation of computeHtmlElement"); |
| return null; |
| } |
| |
| @override |
| List<Source> computeImportedLibraries(Source source) { |
| fail("Unexpected invocation of computeImportedLibraries"); |
| return null; |
| } |
| |
| @override |
| SourceKind computeKindOf(Source source) { |
| fail("Unexpected invocation of computeKindOf"); |
| return null; |
| } |
| |
| @override |
| LibraryElement computeLibraryElement(Source source) { |
| fail("Unexpected invocation of computeLibraryElement"); |
| return null; |
| } |
| |
| @override |
| LineInfo computeLineInfo(Source source) { |
| fail("Unexpected invocation of computeLineInfo"); |
| return null; |
| } |
| |
| @override |
| CompilationUnit computeResolvableCompilationUnit(Source source) { |
| fail("Unexpected invocation of computeResolvableCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| Future<CompilationUnit> computeResolvedCompilationUnitAsync( |
| Source source, Source librarySource) { |
| fail("Unexpected invocation of getResolvedCompilationUnitFuture"); |
| return null; |
| } |
| |
| @override |
| Object computeResult(AnalysisTarget target, ResultDescriptor result) { |
| fail("Unexpected invocation of computeResult"); |
| return null; |
| } |
| |
| @override |
| void dispose() { |
| fail("Unexpected invocation of dispose"); |
| } |
| |
| @override |
| List<CompilationUnit> ensureResolvedDartUnits(Source source) { |
| fail("Unexpected invocation of ensureResolvedDartUnits"); |
| return null; |
| } |
| |
| @override |
| bool exists(Source source) { |
| fail("Unexpected invocation of exists"); |
| return false; |
| } |
| |
| @override |
| CacheEntry getCacheEntry(AnalysisTarget target) { |
| fail("Unexpected invocation of visitCacheItems"); |
| return null; |
| } |
| |
| @override |
| CompilationUnitElement getCompilationUnitElement( |
| Source unitSource, Source librarySource) { |
| fail("Unexpected invocation of getCompilationUnitElement"); |
| return null; |
| } |
| |
| @override |
| TimestampedData<String> getContents(Source source) { |
| fail("Unexpected invocation of getContents"); |
| return null; |
| } |
| |
| @override |
| InternalAnalysisContext getContextFor(Source source) { |
| fail("Unexpected invocation of getContextFor"); |
| return null; |
| } |
| |
| @override |
| Element getElement(ElementLocation location) { |
| fail("Unexpected invocation of getElement"); |
| return null; |
| } |
| |
| @override |
| AnalysisErrorInfo getErrors(Source source) { |
| fail("Unexpected invocation of getErrors"); |
| return null; |
| } |
| |
| @override |
| @deprecated |
| HtmlElement getHtmlElement(Source source) { |
| fail("Unexpected invocation of getHtmlElement"); |
| return null; |
| } |
| |
| @override |
| List<Source> getHtmlFilesReferencing(Source source) { |
| fail("Unexpected invocation of getHtmlFilesReferencing"); |
| return null; |
| } |
| |
| @override |
| SourceKind getKindOf(Source source) { |
| fail("Unexpected invocation of getKindOf"); |
| return null; |
| } |
| |
| @override |
| List<Source> getLibrariesContaining(Source source) { |
| fail("Unexpected invocation of getLibrariesContaining"); |
| return null; |
| } |
| |
| @override |
| List<Source> getLibrariesDependingOn(Source librarySource) { |
| fail("Unexpected invocation of getLibrariesDependingOn"); |
| return null; |
| } |
| |
| @override |
| List<Source> getLibrariesReferencedFromHtml(Source htmlSource) { |
| fail("Unexpected invocation of getLibrariesReferencedFromHtml"); |
| return null; |
| } |
| |
| @override |
| LibraryElement getLibraryElement(Source source) { |
| fail("Unexpected invocation of getLibraryElement"); |
| return null; |
| } |
| |
| @override |
| LineInfo getLineInfo(Source source) { |
| fail("Unexpected invocation of getLineInfo"); |
| return null; |
| } |
| |
| @override |
| int getModificationStamp(Source source) { |
| fail("Unexpected invocation of getModificationStamp"); |
| return 0; |
| } |
| |
| @override |
| ChangeNoticeImpl getNotice(Source source) { |
| fail("Unexpected invocation of getNotice"); |
| return null; |
| } |
| |
| @override |
| Namespace getPublicNamespace(LibraryElement library) { |
| fail("Unexpected invocation of getPublicNamespace"); |
| return null; |
| } |
| |
| @override |
| CompilationUnit getResolvedCompilationUnit( |
| Source unitSource, LibraryElement library) { |
| fail("Unexpected invocation of getResolvedCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| CompilationUnit getResolvedCompilationUnit2( |
| Source unitSource, Source librarySource) { |
| fail("Unexpected invocation of getResolvedCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| @deprecated |
| ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) { |
| fail("Unexpected invocation of getResolvedHtmlUnit"); |
| return null; |
| } |
| |
| @override |
| Object getResult(AnalysisTarget target, ResultDescriptor result) { |
| fail("Unexpected invocation of getResult"); |
| return null; |
| } |
| |
| @override |
| List<Source> getSourcesWithFullName(String path) { |
| fail("Unexpected invocation of getSourcesWithFullName"); |
| return null; |
| } |
| |
| @override |
| bool handleContentsChanged( |
| Source source, String originalContents, String newContents, bool notify) { |
| fail("Unexpected invocation of handleContentsChanged"); |
| return false; |
| } |
| |
| @override |
| void invalidateLibraryHints(Source librarySource) { |
| fail("Unexpected invocation of invalidateLibraryHints"); |
| } |
| |
| @override |
| bool isClientLibrary(Source librarySource) { |
| fail("Unexpected invocation of isClientLibrary"); |
| return false; |
| } |
| |
| @override |
| bool isServerLibrary(Source librarySource) { |
| fail("Unexpected invocation of isServerLibrary"); |
| return false; |
| } |
| |
| @override |
| Stream<ComputedResult> onResultComputed(ResultDescriptor descriptor) { |
| fail("Unexpected invocation of onResultComputed"); |
| return null; |
| } |
| |
| @override |
| CompilationUnit parseCompilationUnit(Source source) { |
| fail("Unexpected invocation of parseCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| Document parseHtmlDocument(Source source) { |
| fail("Unexpected invocation of parseHtmlDocument"); |
| return null; |
| } |
| |
| @override |
| ht.HtmlUnit parseHtmlUnit(Source source) { |
| fail("Unexpected invocation of parseHtmlUnit"); |
| return null; |
| } |
| |
| @override |
| AnalysisResult performAnalysisTask() { |
| fail("Unexpected invocation of performAnalysisTask"); |
| return null; |
| } |
| |
| @override |
| void recordLibraryElements(Map<Source, LibraryElement> elementMap) { |
| fail("Unexpected invocation of recordLibraryElements"); |
| } |
| |
| @override |
| void removeListener(AnalysisListener listener) { |
| fail("Unexpected invocation of removeListener"); |
| } |
| |
| @override |
| CompilationUnit resolveCompilationUnit( |
| Source unitSource, LibraryElement library) { |
| fail("Unexpected invocation of resolveCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| CompilationUnit resolveCompilationUnit2( |
| Source unitSource, Source librarySource) { |
| fail("Unexpected invocation of resolveCompilationUnit"); |
| return null; |
| } |
| |
| @override |
| @deprecated |
| ht.HtmlUnit resolveHtmlUnit(Source htmlSource) { |
| fail("Unexpected invocation of resolveHtmlUnit"); |
| return null; |
| } |
| |
| @override |
| void setChangedContents(Source source, String contents, int offset, |
| int oldLength, int newLength) { |
| fail("Unexpected invocation of setChangedContents"); |
| } |
| |
| @override |
| void setContents(Source source, String contents) { |
| fail("Unexpected invocation of setContents"); |
| } |
| |
| @override |
| bool shouldErrorsBeAnalyzed(Source source, Object entry) { |
| fail("Unexpected invocation of shouldErrorsBeAnalyzed"); |
| return false; |
| } |
| |
| @override |
| void test_flushAstStructures(Source source) { |
| fail("Unexpected invocation of test_flushAstStructures"); |
| } |
| |
| @override |
| bool validateCacheConsistency() { |
| fail("Unexpected invocation of validateCacheConsistency"); |
| return false; |
| } |
| |
| @deprecated |
| @override |
| void visitCacheItems(void callback(Source source, SourceEntry dartEntry, |
| DataDescriptor rowDesc, CacheState state)) { |
| fail("Unexpected invocation of visitCacheItems"); |
| } |
| |
| @override |
| void visitContentCache(ContentCacheVisitor visitor) { |
| fail("Unexpected invocation of visitContentCache"); |
| } |
| } |
| |
| class TestAnalysisContext_test_applyChanges extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_applyChanges(); |
| @override |
| void applyChanges(ChangeSet changeSet) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeDocumentationComment |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeDocumentationComment(); |
| @override |
| String computeDocumentationComment(Element element) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeErrors extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeErrors(); |
| @override |
| List<AnalysisError> computeErrors(Source source) { |
| invoked = true; |
| return AnalysisError.NO_ERRORS; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeExportedLibraries |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeExportedLibraries(); |
| @override |
| List<Source> computeExportedLibraries(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeHtmlElement extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeHtmlElement(); |
| @override |
| @deprecated |
| HtmlElement computeHtmlElement(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeImportedLibraries |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeImportedLibraries(); |
| @override |
| List<Source> computeImportedLibraries(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeKindOf extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeKindOf(); |
| @override |
| SourceKind computeKindOf(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeLibraryElement |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeLibraryElement(); |
| @override |
| LibraryElement computeLibraryElement(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeLineInfo extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeLineInfo(); |
| @override |
| LineInfo computeLineInfo(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_computeResolvableCompilationUnit |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_computeResolvableCompilationUnit(); |
| @override |
| CompilationUnit computeResolvableCompilationUnit(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_dispose extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_dispose(); |
| @override |
| void dispose() { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_exists extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_exists(); |
| @override |
| bool exists(Source source) { |
| invoked = true; |
| return false; |
| } |
| } |
| |
| class TestAnalysisContext_test_getAnalysisOptions extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getAnalysisOptions(); |
| @override |
| AnalysisOptions get analysisOptions { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getCompilationUnitElement |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getCompilationUnitElement(); |
| @override |
| CompilationUnitElement getCompilationUnitElement( |
| Source unitSource, Source librarySource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getContents extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getContents(); |
| @override |
| TimestampedData<String> getContents(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getElement extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getElement(); |
| @override |
| Element getElement(ElementLocation location) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getErrors extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getErrors(); |
| @override |
| AnalysisErrorInfo getErrors(Source source) { |
| invoked = true; |
| return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null); |
| } |
| } |
| |
| class TestAnalysisContext_test_getHtmlElement extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getHtmlElement(); |
| @override |
| @deprecated |
| HtmlElement getHtmlElement(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getHtmlFilesReferencing |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getHtmlFilesReferencing(); |
| @override |
| List<Source> getHtmlFilesReferencing(Source source) { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getHtmlSources extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getHtmlSources(); |
| @override |
| List<Source> get htmlSources { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getKindOf extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getKindOf(); |
| @override |
| SourceKind getKindOf(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLaunchableClientLibrarySources |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLaunchableClientLibrarySources(); |
| @override |
| List<Source> get launchableClientLibrarySources { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLaunchableServerLibrarySources |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLaunchableServerLibrarySources(); |
| @override |
| List<Source> get launchableServerLibrarySources { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLibrariesContaining |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLibrariesContaining(); |
| @override |
| List<Source> getLibrariesContaining(Source source) { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLibrariesDependingOn |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLibrariesDependingOn(); |
| @override |
| List<Source> getLibrariesDependingOn(Source librarySource) { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLibrariesReferencedFromHtml |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLibrariesReferencedFromHtml(); |
| @override |
| List<Source> getLibrariesReferencedFromHtml(Source htmlSource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLibraryElement extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLibraryElement(); |
| @override |
| LibraryElement getLibraryElement(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLibrarySources extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLibrarySources(); |
| @override |
| List<Source> get librarySources { |
| invoked = true; |
| return Source.EMPTY_LIST; |
| } |
| } |
| |
| class TestAnalysisContext_test_getLineInfo extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getLineInfo(); |
| @override |
| LineInfo getLineInfo(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getModificationStamp |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getModificationStamp(); |
| @override |
| int getModificationStamp(Source source) { |
| invoked = true; |
| return 0; |
| } |
| } |
| |
| class TestAnalysisContext_test_getPublicNamespace extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getPublicNamespace(); |
| @override |
| Namespace getPublicNamespace(LibraryElement library) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getResolvedCompilationUnit_element |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getResolvedCompilationUnit_element(); |
| @override |
| CompilationUnit getResolvedCompilationUnit( |
| Source unitSource, LibraryElement library) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getResolvedCompilationUnit_source |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getResolvedCompilationUnit_source(); |
| @override |
| CompilationUnit getResolvedCompilationUnit2( |
| Source unitSource, Source librarySource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getResolvedHtmlUnit extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getResolvedHtmlUnit(); |
| @override |
| @deprecated |
| ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getSourceFactory extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getSourceFactory(); |
| @override |
| SourceFactory get sourceFactory { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getStatistics extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getStatistics(); |
| @override |
| AnalysisContextStatistics get statistics { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_getTypeProvider extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_getTypeProvider(); |
| @override |
| TypeProvider get typeProvider { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_isClientLibrary extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_isClientLibrary(); |
| @override |
| bool isClientLibrary(Source librarySource) { |
| invoked = true; |
| return false; |
| } |
| } |
| |
| class TestAnalysisContext_test_isDisposed extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_isDisposed(); |
| @override |
| bool get isDisposed { |
| invoked = true; |
| return false; |
| } |
| } |
| |
| class TestAnalysisContext_test_isServerLibrary extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_isServerLibrary(); |
| @override |
| bool isServerLibrary(Source librarySource) { |
| invoked = true; |
| return false; |
| } |
| } |
| |
| class TestAnalysisContext_test_parseCompilationUnit |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_parseCompilationUnit(); |
| @override |
| CompilationUnit parseCompilationUnit(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_parseHtmlUnit extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_parseHtmlUnit(); |
| @override |
| ht.HtmlUnit parseHtmlUnit(Source source) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_performAnalysisTask extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_performAnalysisTask(); |
| @override |
| AnalysisResult performAnalysisTask() { |
| invoked = true; |
| return new AnalysisResult(new List<ChangeNotice>(0), 0, null, 0); |
| } |
| } |
| |
| class TestAnalysisContext_test_recordLibraryElements |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_recordLibraryElements(); |
| @override |
| void recordLibraryElements(Map<Source, LibraryElement> elementMap) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_resolveCompilationUnit |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_resolveCompilationUnit(); |
| @override |
| CompilationUnit resolveCompilationUnit2( |
| Source unitSource, Source librarySource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_resolveCompilationUnit_element |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_resolveCompilationUnit_element(); |
| @override |
| CompilationUnit resolveCompilationUnit( |
| Source unitSource, LibraryElement library) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_resolveHtmlUnit extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_resolveHtmlUnit(); |
| @override |
| @deprecated |
| ht.HtmlUnit resolveHtmlUnit(Source htmlSource) { |
| invoked = true; |
| return null; |
| } |
| } |
| |
| class TestAnalysisContext_test_setAnalysisOptions extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_setAnalysisOptions(); |
| @override |
| void set analysisOptions(AnalysisOptions options) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_setAnalysisPriorityOrder |
| extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_setAnalysisPriorityOrder(); |
| @override |
| void set analysisPriorityOrder(List<Source> sources) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_setChangedContents extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_setChangedContents(); |
| @override |
| void setChangedContents(Source source, String contents, int offset, |
| int oldLength, int newLength) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_setContents extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_setContents(); |
| @override |
| void setContents(Source source, String contents) { |
| invoked = true; |
| } |
| } |
| |
| class TestAnalysisContext_test_setSourceFactory extends TestAnalysisContext { |
| bool invoked = false; |
| TestAnalysisContext_test_setSourceFactory(); |
| @override |
| void set sourceFactory(SourceFactory factory) { |
| invoked = true; |
| } |
| } |
| |
| /** |
| * Instances of the class `TestTaskVisitor` implement a task visitor that fails if any of its |
| * methods are invoked. Subclasses typically override the expected methods to not cause a test |
| * failure. |
| */ |
| class TestTaskVisitor<E> implements AnalysisTaskVisitor<E> { |
| @override |
| E visitGenerateDartErrorsTask(GenerateDartErrorsTask task) { |
| fail("Unexpectedly invoked visitGenerateDartErrorsTask"); |
| return null; |
| } |
| |
| @override |
| E visitGenerateDartHintsTask(GenerateDartHintsTask task) { |
| fail("Unexpectedly invoked visitGenerateDartHintsTask"); |
| return null; |
| } |
| |
| @override |
| E visitGenerateDartLintsTask(GenerateDartLintsTask task) { |
| fail("Unexpectedly invoked visitGenerateDartLintsTask"); |
| return null; |
| } |
| |
| @override |
| E visitGetContentTask(GetContentTask task) { |
| fail("Unexpectedly invoked visitGetContentsTask"); |
| return null; |
| } |
| |
| @override |
| E visitIncrementalAnalysisTask( |
| IncrementalAnalysisTask incrementalAnalysisTask) { |
| fail("Unexpectedly invoked visitIncrementalAnalysisTask"); |
| return null; |
| } |
| |
| @override |
| E visitParseDartTask(ParseDartTask task) { |
| fail("Unexpectedly invoked visitParseDartTask"); |
| return null; |
| } |
| |
| @override |
| E visitParseHtmlTask(ParseHtmlTask task) { |
| fail("Unexpectedly invoked visitParseHtmlTask"); |
| return null; |
| } |
| |
| @override |
| E visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) { |
| fail("Unexpectedly invoked visitResolveDartLibraryCycleTask"); |
| return null; |
| } |
| |
| @override |
| E visitResolveDartLibraryTask(ResolveDartLibraryTask task) { |
| fail("Unexpectedly invoked visitResolveDartLibraryTask"); |
| return null; |
| } |
| |
| @override |
| E visitResolveDartUnitTask(ResolveDartUnitTask task) { |
| fail("Unexpectedly invoked visitResolveDartUnitTask"); |
| return null; |
| } |
| |
| @override |
| E visitResolveHtmlTask(ResolveHtmlTask task) { |
| fail("Unexpectedly invoked visitResolveHtmlTask"); |
| return null; |
| } |
| |
| @override |
| E visitScanDartTask(ScanDartTask task) { |
| fail("Unexpectedly invoked visitScanDartTask"); |
| return null; |
| } |
| } |
| |
| @reflectiveTest |
| class UniversalCachePartitionTest extends EngineTestCase { |
| void test_contains() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| TestSource source = new TestSource(); |
| expect(partition.contains(source), isTrue); |
| } |
| |
| void test_creation() { |
| expect(new UniversalCachePartition(null, 8, null), isNotNull); |
| } |
| |
| void test_entrySet() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| TestSource source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| partition.put(source, entry); |
| Map<Source, SourceEntry> entryMap = partition.map; |
| expect(entryMap.length, 1); |
| Source entryKey = entryMap.keys.first; |
| expect(entryKey, same(source)); |
| expect(entryMap[entryKey], same(entry)); |
| } |
| |
| void test_get() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| TestSource source = new TestSource(); |
| expect(partition.get(source), isNull); |
| } |
| |
| void test_put_noFlush() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| TestSource source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| partition.put(source, entry); |
| expect(partition.get(source), same(entry)); |
| } |
| |
| void test_remove() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| TestSource source = new TestSource(); |
| DartEntry entry = new DartEntry(); |
| partition.put(source, entry); |
| expect(partition.get(source), same(entry)); |
| partition.remove(source); |
| expect(partition.get(source), isNull); |
| } |
| |
| void test_setMaxCacheSize() { |
| UniversalCachePartition partition = new UniversalCachePartition( |
| null, 8, new _UniversalCachePartitionTest_test_setMaxCacheSize()); |
| int size = 6; |
| for (int i = 0; i < size; i++) { |
| Source source = new TestSource("/test$i.dart"); |
| DartEntry entry = new DartEntry(); |
| entry.setValue(DartEntry.PARSED_UNIT, null); |
| partition.put(source, entry); |
| partition.accessedAst(source); |
| } |
| _assertNonFlushedCount(size, partition); |
| int newSize = size - 2; |
| partition.maxCacheSize = newSize; |
| _assertNonFlushedCount(newSize, partition); |
| } |
| |
| void test_size() { |
| UniversalCachePartition partition = |
| new UniversalCachePartition(null, 8, null); |
| int size = 4; |
| for (int i = 0; i < size; i++) { |
| Source source = new TestSource("/test$i.dart"); |
| partition.put(source, new DartEntry()); |
| partition.accessedAst(source); |
| } |
| expect(partition.size(), size); |
| } |
| |
| void _assertNonFlushedCount( |
| int expectedCount, UniversalCachePartition partition) { |
| int nonFlushedCount = 0; |
| Map<Source, SourceEntry> entryMap = partition.map; |
| entryMap.values.forEach((SourceEntry value) { |
| if (value.getState(DartEntry.PARSED_UNIT) != CacheState.FLUSHED) { |
| nonFlushedCount++; |
| } |
| }); |
| expect(nonFlushedCount, expectedCount); |
| } |
| } |
| |
| @reflectiveTest |
| class WorkManagerTest extends EngineTestCase { |
| void test_addFirst() { |
| TestSource source1 = new TestSource("/f1.dart"); |
| TestSource source2 = new TestSource("/f2.dart"); |
| WorkManager manager = new WorkManager(); |
| manager.add(source1, SourcePriority.UNKNOWN); |
| manager.addFirst(source2, SourcePriority.UNKNOWN); |
| WorkManager_WorkIterator iterator = manager.iterator(); |
| expect(iterator.next(), same(source2)); |
| expect(iterator.next(), same(source1)); |
| } |
| |
| void test_creation() { |
| expect(new WorkManager(), isNotNull); |
| } |
| |
| void test_iterator_empty() { |
| WorkManager manager = new WorkManager(); |
| WorkManager_WorkIterator iterator = manager.iterator(); |
| expect(iterator.hasNext, isFalse); |
| try { |
| iterator.next(); |
| fail("Expected NoSuchElementException"); |
| } on NoSuchElementException {} |
| } |
| |
| void test_iterator_nonEmpty() { |
| TestSource source = new TestSource(); |
| WorkManager manager = new WorkManager(); |
| manager.add(source, SourcePriority.UNKNOWN); |
| WorkManager_WorkIterator iterator = manager.iterator(); |
| expect(iterator.hasNext, isTrue); |
| expect(iterator.next(), same(source)); |
| } |
| |
| void test_remove() { |
| TestSource source1 = new TestSource("/f1.dart"); |
| TestSource source2 = new TestSource("/f2.dart"); |
| TestSource source3 = new TestSource("/f3.dart"); |
| WorkManager manager = new WorkManager(); |
| manager.add(source1, SourcePriority.UNKNOWN); |
| manager.add(source2, SourcePriority.UNKNOWN); |
| manager.add(source3, SourcePriority.UNKNOWN); |
| manager.remove(source2); |
| WorkManager_WorkIterator iterator = manager.iterator(); |
| expect(iterator.next(), same(source1)); |
| expect(iterator.next(), same(source3)); |
| } |
| |
| void test_toString_empty() { |
| WorkManager manager = new WorkManager(); |
| expect(manager.toString(), isNotNull); |
| } |
| |
| void test_toString_nonEmpty() { |
| WorkManager manager = new WorkManager(); |
| manager.add(new TestSource(), SourcePriority.HTML); |
| manager.add(new TestSource(), SourcePriority.LIBRARY); |
| manager.add(new TestSource(), SourcePriority.NORMAL_PART); |
| manager.add(new TestSource(), SourcePriority.PRIORITY_PART); |
| manager.add(new TestSource(), SourcePriority.UNKNOWN); |
| expect(manager.toString(), isNotNull); |
| } |
| } |
| |
| class _AnalysisCacheTest_test_setMaxCacheSize implements CacheRetentionPolicy { |
| @override |
| RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) => |
| RetentionPriority.LOW; |
| } |
| |
| class _AnalysisContext_sourceChangeDuringResolution |
| extends AnalysisContextForTests { |
| @override |
| DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.changedSource(task.librarySource); |
| applyChanges(changeSet); |
| return super.recordResolveDartLibraryTaskResults(task); |
| } |
| } |
| |
| class _AnalysisContextImplTest_test_applyChanges_removeContainer |
| implements SourceContainer { |
| Source libB; |
| _AnalysisContextImplTest_test_applyChanges_removeContainer(this.libB); |
| @override |
| bool contains(Source source) => source == libB; |
| } |
| |
| class _Source_getContent_throwException extends NonExistingSource { |
| _Source_getContent_throwException(String name) |
| : super(name, pathos.toUri(name), UriKind.FILE_URI); |
| |
| @override |
| TimestampedData<String> get contents { |
| throw 'Read error'; |
| } |
| |
| @override |
| bool exists() => true; |
| } |
| |
| class _UniversalCachePartitionTest_test_setMaxCacheSize |
| implements CacheRetentionPolicy { |
| @override |
| RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) => |
| RetentionPriority.LOW; |
| } |