add source changed event stream

pkg/analyzer/test/generated/engine_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.engine_test;
 
+import 'dart:async';
 import 'dart:collection';
 
 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/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/task/task_dart.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
+import 'package:watcher/src/utils.dart';
 
 import '../reflective_tests.dart';
 import 'all_the_rest.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisCacheTest);
@@ skipping 174 matching lines @@
     _context.analysisOptions = options;
   }
 
   @override
   void tearDown() {
     _context = null;
     _sourceFactory = null;
     super.tearDown();
   }
 
-  void test_applyChanges_add() {
+  Future test_applyChanges_add() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
-    Source source = _addSource("/test.dart", "main() {}");
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.addedSource(source);
+    _context.applyChanges(changeSet);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet);
+      listener.assertNoMoreEvents();
+    });
+  }
+
+  Future test_applyChanges_change() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
+    expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    ChangeSet changeSet2 = new ChangeSet();
+    changeSet2.addedSource(source2);
+    changeSet2.changedSource(source);
+    _context.applyChanges(changeSet2);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      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.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    ChangeSet changeSet2 = new ChangeSet();
+    changeSet2.addedSource(source2);
+    changeSet2.changedContent(source, 'library test;');
+    _context.applyChanges(changeSet2);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_applyChanges_change_flush_element() {
     _context = AnalysisContextFactory.contextWithCore();
     _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);
   }
 
-  void test_applyChanges_change_multiple() {
+  Future test_applyChanges_change_multiple() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    String libraryContents1 = r'''
 library lib;
 part 'part.dart';
-int a = 0;''');
-    Source partSource = _addSource("/part.dart", r'''
+int a = 0;''';
+    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    String partContents1 = r'''
 part of lib;
-int b = a;''');
+int b = a;''';
+    Source partSource = _addSource("/part.dart", partContents1);
     _context.computeLibraryElement(librarySource);
-    _context.setContents(librarySource, r'''
+    String libraryContents2 = r'''
 library lib;
 part 'part.dart';
-int aa = 0;''');
-    _context.setContents(partSource, r'''
+int aa = 0;''';
+    _context.setContents(librarySource, libraryContents2);
+    String partContents2 = r'''
 part of lib;
-int b = aa;''');
+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.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents1
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents1
+      });
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents2
+      });
+      listener.assertChanges(changedContents: {
+        partSource: partContents2
+      });
+      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.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(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.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      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));
   }
 
-  void test_applyChanges_remove() {
+  Future test_applyChanges_remove() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source libA = _addSource("/libA.dart", r'''
+    String libAContents = r'''
 library libA;
-import 'libB.dart';''');
-    Source libB = _addSource("/libB.dart", "library libB;");
+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.assertChanges(added: [libA]);
+      listener.assertChanges(changedContents: {
+        libA: libAContents
+      });
+      listener.assertChanges(added: [libB]);
+      listener.assertChanges(changedContents: {
+        libB: libBContents
+      });
+      listener.assertChanges(changedContents: {
+        libB: null
+      });
+      listener.assertChanges(removedSources: [libB]);
+      listener.assertNoMoreEvents();
+    });
   }
 
-  void test_applyChanges_removeContainer() {
+  Future test_applyChanges_removeContainer() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source libA = _addSource("/libA.dart", r'''
+    String libAContents = r'''
 library libA;
-import 'libB.dart';''');
-    Source libB = _addSource("/libB.dart", "library libB;");
+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();
-    changeSet.removedContainer(
-        new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB));
+    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.assertChanges(added: [libA]);
+      listener.assertChanges(changedContents: {
+        libA: libAContents
+      });
+      listener.assertChanges(added: [libB]);
+      listener.assertChanges(changedContents: {
+        libB: libBContents
+      });
+      listener.assertChanges(removedContainers: [removedContainer]);
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_computeDocumentationComment_block() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     String comment = "/** Comment */";
     Source source = _addSource("/test.dart", """
 $comment
 class A {}""");
     LibraryElement libraryElement = _context.computeLibraryElement(source);
@@ skipping 1266 matching lines @@
     _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;
   }
 
-  void test_setChangedContents_libraryWithPart() {
+  Future test_setChangedContents_libraryWithPart() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.incremental = true;
     _context = AnalysisContextFactory.contextWithCoreAndOptions(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);
-    Source partSource = _addSource("/part.dart", r'''
+    String partContents = r'''
 part of lib;
-int b = a;''');
+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.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: oldCode
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents
+      });
+      listener.assertChanges(changedRanges: {
+        librarySource: new ChangeSet_ContentChange(newCode, offset, 0, 1)
+      });
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_setChangedContents_notResolved() {
     _context = AnalysisContextFactory.contextWithCore();
     AnalysisOptionsImpl options =
         new AnalysisOptionsImpl.con1(_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);
   }
 
-  void test_setContents_libraryWithPart() {
+  Future test_setContents_libraryWithPart() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    String libraryContents1 = r'''
 library lib;
 part 'part.dart';
-int a = 0;''');
-    Source partSource = _addSource("/part.dart", r'''
+int a = 0;''';
+    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    String partContents1 = r'''
 part of lib;
-int b = a;''');
+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));
-    _context.setContents(librarySource, r'''
+    String libraryContents2 = r'''
 library lib;
 part 'part.dart';
-int aa = 0;''');
+int aa = 0;''';
+    _context.setContents(librarySource, libraryContents2);
     expect(
         _context.getResolvedCompilationUnit2(partSource, librarySource),
         isNull);
     expect(_getIncrementalAnalysisCache(_context), isNull);
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents1
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents1
+      });
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents2
+      });
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_setContents_null() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source librarySource = _addSource("/lib.dart", r'''
 library lib;
 int a = 0;''');
     _context.computeLibraryElement(librarySource);
     IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache(
@@ skipping 4280 matching lines @@
     Source source = factory.forUri("dart:core");
     expect(partition.contains(source), isTrue);
   }
 
   void test_creation() {
     expect(new SdkCachePartition(null, 8), isNotNull);
   }
 }
 
 
+class SourcesChangedListener {
+  static const Map<Source, String> EMPTY_CONTENTS_MAP = const {};
+  static const Map<Source, ChangeSet_ContentChange> EMPTY_RANGE_MAP = const {};
+  static const List<SourceContainer> EMPTY_CONTAINER_LIST = const [];
+
+  List<ChangeSet> actualChangeSets = [];
+
+  void assertChanges({List<Source> added: Source.EMPTY_ARRAY,
+      List<Source> changedSources: Source.EMPTY_ARRAY, Map<Source,
+      String> changedContents: EMPTY_CONTENTS_MAP, Map<Source,
+      ChangeSet_ContentChange> changedRanges: EMPTY_RANGE_MAP,
+      List<Source> removedSources: Source.EMPTY_ARRAY,
+      List<SourceContainer> removedContainers: EMPTY_CONTAINER_LIST}) {
+    if (actualChangeSets.isEmpty) {
+      fail('Expected event but found none');
+    }
+    ChangeSet actual = actualChangeSets.removeAt(0);
+    expect(actual.addedSources, added, reason: 'addedSources do not match');
+    expect(
+        actual.changedSources,
+        changedSources,
+        reason: 'changedSources do not match');
+    expect(
+        actual.changedContents,
+        changedContents,
+        reason: 'changedContents do no match');
+
+    HashMap<Source, ChangeSet_ContentChange> actualChangedRanges =
+        actual.changedRanges;
+    Map<Source, ChangeSet_ContentChange> expectedChangedRanges = changedRanges;
+    _expectEqualChangedRanges(actualChangedRanges, expectedChangedRanges);
+
+    expect(actual.deletedSources, []);
+    expect(actual.removedContainers, removedContainers);
+    expect(
+        actual.removedSources,
+        removedSources,
+        reason: 'removedSources do not match');
+  }
+
+  void assertChangeSet(ChangeSet expected) {
+    if (actualChangeSets.isEmpty) {
+      fail('Expected event but found none');
+    }
+    ChangeSet actual = actualChangeSets.removeAt(0);
+    expect(actual, expected);
+  }
+
+  void assertNoMoreEvents() {
+    expect(actualChangeSets, []);
+  }
+
+  void onData(ChangeSet event) {
+    actualChangeSets.add(event);
+  }
+
+  void _expectEqualChangedRanges(Map<Source, ChangeSet_ContentChange> actual,
+      Map<Source, ChangeSet_ContentChange> expected) {
+    expect(actual, hasLength(expected.length));
+    expected.forEach((Source source, ChangeSet_ContentChange expectedChange) {
+      ChangeSet_ContentChange actualChange = actual[source];
+      expect(actualChange.contents, expectedChange.contents);
+      expect(actualChange.offset, expectedChange.offset);
+      expect(actualChange.oldLength, expectedChange.oldLength);
+      expect(actualChange.newLength, expectedChange.newLength);
+    });
+  }
+}
+
+
 /**
  * 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
   AnalysisOptions get analysisOptions {
     fail("Unexpected invocation of getAnalysisOptions");
     return null;
   }
@@ skipping 29 matching lines @@
   List<Source> get launchableServerLibrarySources {
     fail("Unexpected invocation of getLaunchableServerLibrarySources");
     return null;
   }
   @override
   List<Source> get librarySources {
     fail("Unexpected invocation of getLibrarySources");
     return null;
   }
   @override
+  Stream<ChangeSet> get onSourcesChanged {
+    fail("Unexpected invocation of onSourcesChanged");
+    return null;
+  }
+  @override
   List<Source> get prioritySources {
     fail("Unexpected invocation of getPrioritySources");
     return null;
   }
   @override
   List<Source> get refactoringUnsafeSources {
     fail("Unexpected invocation of getRefactoringUnsafeSources");
     return null;
   }
   @override
@@ skipping 1143 matching lines @@
   bool contains(Source source) => source == libB;
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }