A local file-based Index implementation.

pkg/analysis_server/test/index/store/split_store_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.
 
-library test.index.split.store;
+library test.index.split_store;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/index/store/codec.dart';
 import 'package:analysis_server/src/index/store/split_store.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/index.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../reflective_tests.dart';
+import 'single_source_container.dart';
 import 'typed_mocks.dart';
 
 
 main() {
   groupSep = ' | ';
   group('FileNodeManager', () {
     runReflectiveTests(_FileNodeManagerTest);
   });
   group('IndexNode', () {
     runReflectiveTests(_IndexNodeTest);
@@ skipping 504 matching lines @@
     // equals
     expect(keyData == this, isFalse);
     expect(keyData == new RelationKeyData.forData(10, 20), isFalse);
     expect(keyData == keyData, isTrue);
     expect(keyData == new RelationKeyData.forData(elementId, relationshipId),
         isTrue);
   }
 }
 
 
-class _SingleSourceContainer implements SourceContainer {
-  final Source _source;
-  _SingleSourceContainer(this._source);
-  @override
-  bool contains(Source source) => source == _source;
-}
 
 
 @ReflectiveTestCase()
 class _SplitIndexStoreTest {
   AnalysisContext contextA = new MockAnalysisContext('contextA');
 
   AnalysisContext contextB = new MockAnalysisContext('contextB');
 
   AnalysisContext contextC = new MockAnalysisContext('contextC');
 
@@ skipping 68 matching lines @@
     when(unitElementC.library).thenReturn(libraryElement);
     when(unitElementD.library).thenReturn(libraryElement);
     when(htmlElementA.source).thenReturn(sourceA);
     when(htmlElementB.source).thenReturn(sourceB);
     // library
     when(libraryUnitElement.library).thenReturn(libraryElement);
     when(libraryUnitElement.source).thenReturn(librarySource);
     when(libraryElement.source).thenReturn(librarySource);
     when(libraryElement.definingCompilationUnit).thenReturn(libraryUnitElement);
   }
+
   void test_aboutToIndexDart_disposedContext() {
     when(contextA.isDisposed).thenReturn(true);
     expect(store.aboutToIndexDart(contextA, unitElementA), isFalse);
   }
+
   void test_aboutToIndexDart_disposedContext_wrapped() {
     when(contextA.isDisposed).thenReturn(true);
     InstrumentedAnalysisContextImpl instrumentedContext =
         new MockInstrumentedAnalysisContextImpl();
     when(instrumentedContext.basis).thenReturn(contextA);
     expect(store.aboutToIndexDart(instrumentedContext, unitElementA), isFalse);
   }
 
   void test_aboutToIndexDart_library_first() {
     when(libraryElement.parts).thenReturn(<CompilationUnitElement>[unitElementA,
@@ skipping 292 matching lines @@
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     // "A" and "B" locations
     return store.getRelationshipsAsync(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // remove "librarySource"
-      store.removeSources(contextA, new _SingleSourceContainer(librarySource));
+      store.removeSources(contextA, new SingleSourceContainer(librarySource));
       return store.getRelationshipsAsync(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, []);
       });
     });
   }
 
   void test_removeSources_nullContext() {
     store.removeSources(null, null);
   }
@@ skipping 16 matching lines @@
       store.aboutToIndexDart(contextA, unitElementC);
       store.recordRelationship(elementA, relationship, locationC);
       store.doneIndex();
     }
     // "A", "B" and "C" locations
     return store.getRelationshipsAsync(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB, locationC]);
     }).then((_) {
       // remove "A" source
-      store.removeSources(contextA, new _SingleSourceContainer(sourceA));
+      store.removeSources(contextA, new SingleSourceContainer(sourceA));
       store.removeSource(contextA, sourceA);
       return store.getRelationshipsAsync(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, [locationB, locationC]);
       });
     });
   }
 
   test_universe_aboutToIndex() {
     when(contextA.getElement(elementLocationA)).thenReturn(elementA);
@@ skipping 50 matching lines @@
     }).then((_) {
       // remove "contextA"
       store.removeContext(contextA);
       return store.getRelationshipsAsync(UniverseElement.INSTANCE,
           relationship).then((List<Location> locations) {
         assertLocations(locations, [locationB]);
       });
     });
   }
 
+  test_universe_removeSource() {
+    when(contextA.getElement(elementLocationA)).thenReturn(elementA);
+    when(contextB.getElement(elementLocationB)).thenReturn(elementB);
+    Location locationA = mockLocation(elementA);
+    Location locationB = mockLocation(elementB);
+    {
+      store.aboutToIndexDart(contextA, unitElementA);
+      store.recordRelationship(UniverseElement.INSTANCE, relationship,
+          locationA);
+      store.doneIndex();
+    }
+    {
+      store.aboutToIndexDart(contextA, unitElementB);
+      store.recordRelationship(UniverseElement.INSTANCE, relationship,
+          locationB);
+      store.doneIndex();
+    }
+    return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+        relationship).then((List<Location> locations) {
+      assertLocations(locations, [locationA, locationB]);
+    }).then((_) {
+      // remove "sourceA"
+      store.removeSource(contextA, sourceA);
+      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+          relationship).then((List<Location> locations) {
+        assertLocations(locations, [locationB]);
+      });
+    });
+  }
+
+  test_universe_clear() {
+    when(contextA.getElement(elementLocationA)).thenReturn(elementA);
+    when(contextB.getElement(elementLocationB)).thenReturn(elementB);
+    Location locationA = mockLocation(elementA);
+    Location locationB = mockLocation(elementB);
+    {
+      store.aboutToIndexDart(contextA, unitElementA);
+      store.recordRelationship(UniverseElement.INSTANCE, relationship,
+          locationA);
+      store.doneIndex();
+    }
+    {
+      store.aboutToIndexDart(contextA, unitElementB);
+      store.recordRelationship(UniverseElement.INSTANCE, relationship,
+          locationB);
+      store.doneIndex();
+    }
+    return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+        relationship).then((List<Location> locations) {
+      assertLocations(locations, [locationA, locationB]);
+    }).then((_) {
+      // clear
+      store.clear();
+      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+          relationship).then((List<Location> locations) {
+        expect(locations, isEmpty);
+      });
+    });
+  }
+
   /**
    * Asserts that the [actual] locations have all the [expected] locations and
    * only them.
    */
   static void assertLocations(List<Location> actual, List<Location> expected) {
     List<_LocationEqualsWrapper> actualWrappers = wrapLocations(actual);
     List<_LocationEqualsWrapper> expectedWrappers = wrapLocations(expected);
     expect(actualWrappers, unorderedEquals(expectedWrappers));
   }
 
@@ skipping 12 matching lines @@
    * Wraps the given locations into [LocationEqualsWrapper].
    */
   static List<_LocationEqualsWrapper> wrapLocations(List<Location> locations) {
     List<_LocationEqualsWrapper> wrappers = <_LocationEqualsWrapper>[];
     for (Location location in locations) {
       wrappers.add(new _LocationEqualsWrapper(location));
     }
     return wrappers;
   }
 }