Move Index and IndexStore implementations into Engine.

pkg/analyzer/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.engine.src.index.split_store;
 
 import 'dart:async';
 
-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 'memory_node_manager.dart';
 import 'single_source_container.dart';
 import 'typed_mocks.dart';
+import 'package:analyzer/src/index/store/split_store.dart';
+import 'package:analyzer/index/index.dart';
+import 'package:analyzer/src/index/store/codec.dart';
+import 'package:analyzer/src/index/store/memory_node_manager.dart';
 
 
 main() {
   groupSep = ' | ';
   group('FileNodeManager', () {
     runReflectiveTests(_FileNodeManagerTest);
   });
   group('IndexNode', () {
     runReflectiveTests(_IndexNodeTest);
   });
@@ skipping 521 matching lines @@
   }
 
   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() {
+  Future test_aboutToIndexDart_library_first() {
     when(libraryElement.parts).thenReturn(<CompilationUnitElement>[unitElementA,
         unitElementB]);
     {
       store.aboutToIndexDart(contextA, libraryUnitElement);
       store.doneIndex();
     }
-    {
-      List<Location> locations = store.getRelationships(elementA, relationship);
+    return store.getRelationships(elementA, relationship).then(
+        (List<Location> locations) {
       assertLocations(locations, []);
-    }
+    });
   }
 
   test_aboutToIndexDart_library_secondWithoutOneUnit() {
     Location locationA = mockLocation(elementA);
     Location locationB = mockLocation(elementB);
     {
       store.aboutToIndexDart(contextA, unitElementA);
       store.recordRelationship(elementA, relationship, locationA);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     // "A" and "B" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
-    }).then((_) {
       // apply "libraryUnitElement", only with "B"
       when(libraryElement.parts).thenReturn([unitElementB]);
       {
         store.aboutToIndexDart(contextA, libraryUnitElement);
         store.doneIndex();
       }
-      return store.getRelationshipsAsync(elementA, relationship).then(
+    }).then((_) {
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, [locationB]);
       });
     });
   }
 
   void test_aboutToIndexDart_nullLibraryElement() {
     when(unitElementA.library).thenReturn(null);
     expect(store.aboutToIndexDart(contextA, unitElementA), isFalse);
   }
@@ skipping 14 matching lines @@
       store.aboutToIndexHtml(contextA, htmlElementA);
       store.recordRelationship(elementA, relationship, locationA);
       store.doneIndex();
     }
     {
       store.aboutToIndexHtml(contextA, htmlElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     // "A" and "B" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     });
   }
 
   void test_aboutToIndexHtml_disposedContext() {
     when(contextA.isDisposed).thenReturn(true);
     expect(store.aboutToIndexHtml(contextA, htmlElementA), isFalse);
   }
 
   void test_clear() {
     Location locationA = mockLocation(elementA);
     store.aboutToIndexDart(contextA, unitElementA);
     store.recordRelationship(elementA, relationship, locationA);
     store.doneIndex();
     expect(nodeManager.isEmpty(), isFalse);
     // clear
     store.clear();
     expect(nodeManager.isEmpty(), isTrue);
   }
 
   test_getRelationships_empty() {
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       expect(locations, isEmpty);
     });
   }
 
   void test_getStatistics() {
     // empty initially
     {
       String statistics = store.statistics;
       expect(statistics, contains('0 locations'));
@@ skipping 38 matching lines @@
     {
       store.aboutToIndexDart(contextA, unitElementA);
       store.recordRelationship(elementA, relationship, locationA);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     });
   }
 
   test_recordRelationship_oneLocation() {
     Location locationA = mockLocation(elementA);
     store.aboutToIndexDart(contextA, unitElementA);
     store.recordRelationship(elementA, relationship, locationA);
     store.doneIndex();
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA]);
     });
   }
 
   test_recordRelationship_twoLocations() {
     Location locationA = mockLocation(elementA);
     Location locationB = mockLocation(elementA);
     store.aboutToIndexDart(contextA, unitElementA);
     store.recordRelationship(elementA, relationship, locationA);
     store.recordRelationship(elementA, relationship, locationB);
     store.doneIndex();
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     });
   }
 
   test_removeContext() {
     Location locationA = mockLocation(elementA);
     Location locationB = mockLocation(elementB);
     {
       store.aboutToIndexDart(contextA, unitElementA);
       store.recordRelationship(elementA, relationship, locationA);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     // "A" and "B" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
-    }).then((_) {
       // remove "A" context
       store.removeContext(contextA);
-      return store.getRelationshipsAsync(elementA, relationship).then(
+    }).then((_) {
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, []);
       });
     });
   }
 
   void test_removeContext_nullContext() {
     store.removeContext(null);
   }
 
@@ skipping 10 matching lines @@
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementC);
       store.recordRelationship(elementA, relationship, locationC);
       store.doneIndex();
     }
     // "A", "B" and "C" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB, locationC]);
     }).then((_) {
       // remove "librarySource"
       store.removeSource(contextA, librarySource);
-      return store.getRelationshipsAsync(elementA, relationship).then(
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, []);
       });
     });
   }
 
   void test_removeSource_nullContext() {
     store.removeSource(null, sourceA);
   }
 
@@ skipping 10 matching lines @@
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementC);
       store.recordRelationship(elementA, relationship, locationC);
       store.doneIndex();
     }
     // "A", "B" and "C" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB, locationC]);
     }).then((_) {
       // remove "A" source
       store.removeSource(contextA, sourceA);
-      return store.getRelationshipsAsync(elementA, relationship).then(
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, [locationB, locationC]);
       });
     });
   }
 
   test_removeSources_library() {
     Location locationA = mockLocation(elementA);
     Location locationB = mockLocation(elementB);
     {
       store.aboutToIndexDart(contextA, unitElementA);
       store.recordRelationship(elementA, relationship, locationA);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     // "A" and "B" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // remove "librarySource"
       store.removeSources(contextA, new SingleSourceContainer(librarySource));
-      return store.getRelationshipsAsync(elementA, relationship).then(
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, []);
       });
     });
   }
 
   void test_removeSources_nullContext() {
     store.removeSources(null, null);
   }
 
@@ skipping 10 matching lines @@
       store.aboutToIndexDart(contextA, unitElementB);
       store.recordRelationship(elementA, relationship, locationB);
       store.doneIndex();
     }
     {
       store.aboutToIndexDart(contextA, unitElementC);
       store.recordRelationship(elementA, relationship, locationC);
       store.doneIndex();
     }
     // "A", "B" and "C" locations
-    return store.getRelationshipsAsync(elementA, relationship).then(
+    return store.getRelationships(elementA, relationship).then(
         (List<Location> locations) {
       assertLocations(locations, [locationA, locationB, locationC]);
     }).then((_) {
       // remove "A" source
       store.removeSources(contextA, new SingleSourceContainer(sourceA));
       store.removeSource(contextA, sourceA);
-      return store.getRelationshipsAsync(elementA, relationship).then(
+      return store.getRelationships(elementA, relationship).then(
           (List<Location> locations) {
         assertLocations(locations, [locationB, locationC]);
       });
     });
   }
 
   test_universe_aboutToIndex() {
     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(contextB, unitElementB);
       store.recordRelationship(UniverseElement.INSTANCE, relationship,
           locationB);
       store.doneIndex();
     }
     // get relationships
-    return store.getRelationshipsAsync(UniverseElement.INSTANCE,
-        relationship).then((List<Location> locations) {
+    return store.getRelationships(UniverseElement.INSTANCE, relationship).then(
+        (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // re-index "unitElementA"
       store.aboutToIndexDart(contextA, unitElementA);
       store.doneIndex();
-      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+      return store.getRelationships(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) {
+    return store.getRelationships(UniverseElement.INSTANCE, relationship).then(
+        (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // clear
       store.clear();
-      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+      return store.getRelationships(UniverseElement.INSTANCE,
           relationship).then((List<Location> locations) {
         expect(locations, isEmpty);
       });
     });
   }
 
   test_universe_removeContext() {
     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(contextB, unitElementB);
       store.recordRelationship(UniverseElement.INSTANCE, relationship,
           locationB);
       store.doneIndex();
     }
-    return store.getRelationshipsAsync(UniverseElement.INSTANCE,
-        relationship).then((List<Location> locations) {
+    return store.getRelationships(UniverseElement.INSTANCE, relationship).then(
+        (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // remove "contextA"
       store.removeContext(contextA);
-      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+      return store.getRelationships(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) {
+    return store.getRelationships(UniverseElement.INSTANCE, relationship).then(
+        (List<Location> locations) {
       assertLocations(locations, [locationA, locationB]);
     }).then((_) {
       // remove "sourceA"
       store.removeSource(contextA, sourceA);
-      return store.getRelationshipsAsync(UniverseElement.INSTANCE,
+      return store.getRelationships(UniverseElement.INSTANCE,
           relationship).then((List<Location> locations) {
         assertLocations(locations, [locationB]);
       });
     });
   }
 
   /**
    * Asserts that the [actual] locations have all the [expected] locations and
    * only them.
    */
@@ skipping 18 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;
   }
 }