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/string_source.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);
   runReflectiveTests(AnalysisContextImplTest);
   runReflectiveTests(AnalysisTaskTest);
   runReflectiveTests(AnalysisOptionsImplTest);
   runReflectiveTests(DartEntryTest);
   runReflectiveTests(GenerateDartErrorsTaskTest);
   runReflectiveTests(GenerateDartHintsTaskTest);
   runReflectiveTests(GetContentTaskTest);
   runReflectiveTests(HtmlEntryTest);
   runReflectiveTests(IncrementalAnalysisCacheTest);
   runReflectiveTests(InstrumentedAnalysisContextImplTest);
   runReflectiveTests(IncrementalAnalysisTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(ParseHtmlTaskTest);
   runReflectiveTests(PartitionManagerTest);
   runReflectiveTests(ResolveDartLibraryTaskTest);
   runReflectiveTests(ResolveDartUnitTaskTest);
   runReflectiveTests(ResolveHtmlTaskTest);
   runReflectiveTests(ScanDartTaskTest);
   runReflectiveTests(SdkCachePartitionTest);
+  runReflectiveTests(SourcesChangedEventTest);
   runReflectiveTests(UniversalCachePartitionTest);
   runReflectiveTests(WorkManagerTest);
 }
 
 
 class AnalysisCacheTest extends EngineTestCase {
   void test_creation() {
     expect(new AnalysisCache(new List<CachePartition>(0)), isNotNull);
   }
 
@@ skipping 145 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.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.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.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.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.assertEvent(wereSourcesAdded: true);
+      listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
+      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.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.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.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));
   }
 
-  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.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();
+    });
   }
 
-  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.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.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.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.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.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.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 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_ARRAY,
+    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_ARRAY,
+      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
   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<SourcesChangedEvent> 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;
 }