Use single quotes for index store.

pkg/analysis_server/test/index/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;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/index/split_store.dart';
@@ skipping 76 matching lines @@
   AnalysisContext context = new _MockAnalysisContext('context');
   StringCodec stringCodec = new StringCodec();
 
   void setUp() {
     codec = new ElementCodec(stringCodec);
   }
 
   void test_localLocalVariable() {
     {
       Element element = new _MockElement();
-      ElementLocation location = new ElementLocationImpl.con3(["main", "foo@1",
-          "bar@2"]);
+      ElementLocation location = new ElementLocationImpl.con3(['main', 'foo@1',
+          'bar@2']);
       when(context.getElement(location)).thenReturn(element);
       when(element.location).thenReturn(location);
       int id = codec.encode(element);
       expect(codec.decode(context, id), element);
     }
     {
       Element element = new _MockElement();
-      ElementLocation location = new ElementLocationImpl.con3(["main", "foo@10",
-          "bar@20"]);
+      ElementLocation location = new ElementLocationImpl.con3(['main', 'foo@10',
+          'bar@20']);
       when(context.getElement(location)).thenReturn(element);
       when(element.location).thenReturn(location);
       int id = codec.encode(element);
       expect(codec.decode(context, id), element);
     }
     // check strings, "foo" as a single string, no "foo@1" or "foo@10"
     expect(stringCodec.nameToIndex, hasLength(3));
     expect(stringCodec.nameToIndex, containsPair('main', 0));
     expect(stringCodec.nameToIndex, containsPair('foo', 1));
     expect(stringCodec.nameToIndex, containsPair('bar', 2));
   }
 
   void test_localVariable() {
     {
       Element element = new _MockElement();
-      ElementLocation location = new ElementLocationImpl.con3(["main",
-          "foo@42"]);
+      ElementLocation location = new ElementLocationImpl.con3(['main',
+          'foo@42']);
       when(context.getElement(location)).thenReturn(element);
       when(element.location).thenReturn(location);
       int id = codec.encode(element);
       expect(codec.decode(context, id), element);
     }
     {
       Element element = new _MockElement();
-      ElementLocation location = new ElementLocationImpl.con3(["main",
-          "foo@4200"]);
+      ElementLocation location = new ElementLocationImpl.con3(['main',
+          'foo@4200']);
       when(context.getElement(location)).thenReturn(element);
       when(element.location).thenReturn(location);
       int id = codec.encode(element);
       expect(codec.decode(context, id), element);
     }
     // check strings, "foo" as a single string, no "foo@42" or "foo@4200"
     expect(stringCodec.nameToIndex, hasLength(2));
     expect(stringCodec.nameToIndex, containsPair('main', 0));
     expect(stringCodec.nameToIndex, containsPair('foo', 1));
   }
 
   void test_notLocal() {
     Element element = new _MockElement();
-    ElementLocation location = new ElementLocationImpl.con3(["foo", "bar"]);
+    ElementLocation location = new ElementLocationImpl.con3(['foo', 'bar']);
     when(element.location).thenReturn(location);
     when(context.getElement(location)).thenReturn(element);
     int id = codec.encode(element);
     expect(codec.encode(element), id);
     expect(codec.decode(context, id), element);
     // check strings
     expect(stringCodec.nameToIndex, hasLength(2));
     expect(stringCodec.nameToIndex, containsPair('foo', 0));
     expect(stringCodec.nameToIndex, containsPair('bar', 1));
   }
@@ skipping 24 matching lines @@
   void test_clear() {
     nodeManager.clear();
     verify(fileManager.clear()).once();
   }
 
   void test_getLocationCount_empty() {
     expect(nodeManager.locationCount, 0);
   }
 
   void test_getNode_contextNull() {
-    String name = "42.index";
+    String name = '42.index';
     // record bytes
     List<int> bytes;
     when(fileManager.write(name, anyObject)).thenInvoke((name, bs) {
       bytes = bs;
     });
     // put Node
     Future putFuture;
     {
       IndexNode node = new IndexNode(context, elementCodec, relationshipCodec);
       putFuture = nodeManager.putNode(name, node);
     }
     // do in the "put" Future
     putFuture.then((_) {
       // force "null" context
       when(contextCodec.decode(contextId)).thenReturn(null);
       // prepare input bytes
       when(fileManager.read(name)).thenReturn(new Future.value(bytes));
       // get Node
       return nodeManager.getNode(name).then((IndexNode node) {
         expect(node, isNull);
         // no exceptions
         verifyZeroInteractions(logger);
       });
     });
   }
 
   test_getNode_invalidVersion() {
-    String name = "42.index";
+    String name = '42.index';
     // prepare a stream with an invalid version
     when(fileManager.read(name)).thenReturn(new Future.value([0x01, 0x02, 0x03,
         0x04]));
     // do in the Future
     return nodeManager.getNode(name).then((IndexNode node) {
       // no IndexNode
       expect(node, isNull);
       // failed
       verify(logger.logError2(anyObject, anyObject)).once();
     });
   }
 
   test_getNode_streamException() {
-    String name = "42.index";
+    String name = '42.index';
     when(fileManager.read(name)).thenReturn(new Future(() {
       return throw new Exception();
     }));
     // do in the Future
     return nodeManager.getNode(name).then((IndexNode node) {
       expect(node, isNull);
       // failed
       verify(logger.logError2(anyString, anyObject)).once();
     });
   }
 
   test_getNode_streamNull() {
-    String name = "42.index";
+    String name = '42.index';
     when(fileManager.read(name)).thenReturn(new Future.value(null));
     // do in the Future
     return nodeManager.getNode(name).then((IndexNode node) {
       expect(node, isNull);
       // OK
       verifyZeroInteractions(logger);
     });
   }
 
   void test_newNode() {
     IndexNode node = nodeManager.newNode(context);
     expect(node.context, context);
     expect(node.locationCount, 0);
   }
 
   test_putNode_getNode() {
-    String name = "42.index";
+    String name = '42.index';
     // record bytes
     List<int> bytes;
     when(fileManager.write(name, anyObject)).thenInvoke((name, bs) {
       bytes = bs;
     });
     // prepare elements
     Element elementA = _mockElement();
     Element elementB = _mockElement();
     Element elementC = _mockElement();
-    Relationship relationship = Relationship.getRelationship("my-relationship");
+    Relationship relationship = Relationship.getRelationship('my-relationship');
     // put Node
     Future putFuture;
     {
       // prepare relations
       int elementIdA = 0;
       int elementIdB = 1;
       int elementIdC = 2;
       int relationshipId = relationshipCodec.encode(relationship);
       RelationKeyData key = new RelationKeyData.forData(elementIdA,
           relationshipId);
@@ skipping 24 matching lines @@
               relationship);
           expect(locations, hasLength(2));
           _assertHasLocation(locations, elementB, 1, 10);
           _assertHasLocation(locations, elementC, 2, 20);
         }
       });
     });
   }
 
   test_putNode_streamException() {
-    String name = "42.index";
+    String name = '42.index';
     Exception exception = new Exception();
     when(fileManager.write(name, anyObject)).thenReturn(new Future(() {
       return throw exception;
     }));
     // prepare IndexNode
     IndexNode node = new _MockIndexNode();
     when(node.context).thenReturn(context);
     when(node.locationCount).thenReturn(0);
     when(node.relations).thenReturn({});
     // try to put
     return nodeManager.putNode(name, node).then((_) {
       // failed
       verify(logger.logError2(anyString, anyObject)).once();
     });
   }
 
   void test_removeNode() {
-    String name = "42.index";
+    String name = '42.index';
     nodeManager.removeNode(name);
     verify(fileManager.delete(name)).once();
   }
 
   Element _mockElement() {
     int elementId = nextElementId++;
     Element element = new _MockElement();
     when(elementCodec.encode(element)).thenReturn(elementId);
     when(elementCodec.decode(context, elementId)).thenReturn(element);
     return element;
@@ skipping 16 matching lines @@
   }
 
   void test_getContext() {
     expect(node.context, context);
   }
 
   void test_recordRelationship() {
     Element elementA = _mockElement();
     Element elementB = _mockElement();
     Element elementC = _mockElement();
-    Relationship relationship = Relationship.getRelationship("my-relationship");
+    Relationship relationship = Relationship.getRelationship('my-relationship');
     Location locationA = new Location(elementB, 1, 2);
     Location locationB = new Location(elementC, 10, 20);
     // empty initially
     expect(node.locationCount, 0);
     // record
     node.recordRelationship(elementA, relationship, locationA);
     expect(node.locationCount, 1);
     node.recordRelationship(elementA, relationship, locationB);
     expect(node.locationCount, 2);
     // get relations
@@ skipping 10 matching lines @@
       expect(relations, hasLength(1));
       List<LocationData> locations = relations.values.first;
       expect(locations, hasLength(2));
     }
   }
 
   void test_setRelations() {
     Element elementA = _mockElement();
     Element elementB = _mockElement();
     Element elementC = _mockElement();
-    Relationship relationship = Relationship.getRelationship("my-relationship");
+    Relationship relationship = Relationship.getRelationship('my-relationship');
     // record
     {
       int elementIdA = 0;
       int elementIdB = 1;
       int elementIdC = 2;
       int relationshipId = relationshipCodec.encode(relationship);
       RelationKeyData key = new RelationKeyData.forData(elementIdA,
           relationshipId);
       List<LocationData> locations = [new LocationData.forData(elementIdB, 1,
           10), new LocationData.forData(elementIdC, 2, 20)];
@@ skipping 313 matching lines @@
     expect(keyData == keyData, isTrue);
     expect(keyData == new RelationKeyData.forData(1, 2), isTrue);
   }
 
   void test_newFromObjects() {
     // prepare Element
     Element element;
     int elementId = 2;
     {
       element = new _MockElement();
-      ElementLocation location = new ElementLocationImpl.con3(["foo", "bar"]);
+      ElementLocation location = new ElementLocationImpl.con3(['foo', 'bar']);
       when(element.location).thenReturn(location);
       when(context.getElement(location)).thenReturn(element);
       when(elementCodec.encode(element)).thenReturn(elementId);
     }
     // prepare relationship
-    Relationship relationship = Relationship.getRelationship("my-relationship");
+    Relationship relationship = Relationship.getRelationship('my-relationship');
     int relationshipId = 1;
     when(relationshipCodec.encode(relationship)).thenReturn(relationshipId);
     // create RelationKeyData
     RelationKeyData keyData = new RelationKeyData.forObject(elementCodec,
         relationshipCodec, element, relationship);
     // touch
     keyData.hashCode;
     // 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);
   }
 }
 
 
 @ReflectiveTestCase()
 class _RelationshipCodecTest {
   RelationshipCodec codec;
   StringCodec stringCodec = new StringCodec();
 
   void setUp() {
     codec = new RelationshipCodec(stringCodec);
   }
 
   void test_all() {
-    Relationship relationship = Relationship.getRelationship("my-relationship");
+    Relationship relationship = Relationship.getRelationship('my-relationship');
     int id = codec.encode(relationship);
     expect(codec.decode(id), relationship);
   }
 }
 
 
 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');
 
   Element elementA = new _MockElement('elementA');
   Element elementB = new _MockElement('elementB');
 
   Element elementC = new _MockElement('elementC');
   Element elementD = new _MockElement('elementD');
   ElementLocation elementLocationA = new ElementLocationImpl.con3(
-      ["/home/user/sourceA.dart", "ClassA"]);
+      ['/home/user/sourceA.dart', 'ClassA']);
   ElementLocation elementLocationB = new ElementLocationImpl.con3(
-      ["/home/user/sourceB.dart", "ClassB"]);
+      ['/home/user/sourceB.dart', 'ClassB']);
   ElementLocation elementLocationC = new ElementLocationImpl.con3(
-      ["/home/user/sourceC.dart", "ClassC"]);
+      ['/home/user/sourceC.dart', 'ClassC']);
   ElementLocation elementLocationD = new ElementLocationImpl.con3(
-      ["/home/user/sourceD.dart", "ClassD"]);
+      ['/home/user/sourceD.dart', 'ClassD']);
   HtmlElement htmlElementA = new _MockHtmlElement();
   HtmlElement htmlElementB = new _MockHtmlElement();
   LibraryElement libraryElement = new _MockLibraryElement();
   Source librarySource = new _MockSource('librarySource');
   CompilationUnitElement libraryUnitElement = new _MockCompilationUnitElement();
   _MemoryNodeManager nodeManager = new _MemoryNodeManager();
-  Relationship relationship = Relationship.getRelationship("test-relationship");
+  Relationship relationship = Relationship.getRelationship('test-relationship');
   Source sourceA = new _MockSource('sourceA');
   Source sourceB = new _MockSource('sourceB');
   Source sourceC = new _MockSource('sourceC');
   Source sourceD = new _MockSource('sourceD');
   SplitIndexStore store;
   CompilationUnitElement unitElementA = new _MockCompilationUnitElement();
   CompilationUnitElement unitElementB = new _MockCompilationUnitElement();
   CompilationUnitElement unitElementC = new _MockCompilationUnitElement();
   CompilationUnitElement unitElementD = new _MockCompilationUnitElement();
   void setUp() {
     store = new SplitIndexStore(nodeManager);
     when(contextA.isDisposed).thenReturn(false);
     when(contextB.isDisposed).thenReturn(false);
     when(contextC.isDisposed).thenReturn(false);
     when(contextA.getElement(elementLocationA)).thenReturn(elementA);
     when(contextA.getElement(elementLocationB)).thenReturn(elementB);
     when(contextA.getElement(elementLocationC)).thenReturn(elementC);
     when(contextA.getElement(elementLocationD)).thenReturn(elementD);
-    when(sourceA.fullName).thenReturn("/home/user/sourceA.dart");
-    when(sourceB.fullName).thenReturn("/home/user/sourceB.dart");
-    when(sourceC.fullName).thenReturn("/home/user/sourceC.dart");
-    when(sourceD.fullName).thenReturn("/home/user/sourceD.dart");
+    when(sourceA.fullName).thenReturn('/home/user/sourceA.dart');
+    when(sourceB.fullName).thenReturn('/home/user/sourceB.dart');
+    when(sourceC.fullName).thenReturn('/home/user/sourceC.dart');
+    when(sourceD.fullName).thenReturn('/home/user/sourceD.dart');
     when(elementA.context).thenReturn(contextA);
     when(elementB.context).thenReturn(contextA);
     when(elementC.context).thenReturn(contextA);
     when(elementD.context).thenReturn(contextA);
     when(elementA.location).thenReturn(elementLocationA);
     when(elementB.location).thenReturn(elementLocationB);
     when(elementC.location).thenReturn(elementLocationC);
     when(elementD.location).thenReturn(elementLocationD);
     when(elementA.enclosingElement).thenReturn(unitElementA);
     when(elementB.enclosingElement).thenReturn(unitElementB);
@@ skipping 441 matching lines @@
       // remove "contextA"
       store.removeContext(contextA);
       return store.getRelationshipsAsync(UniverseElement.INSTANCE,
           relationship).then((List<Location> locations) {
         assertLocations(locations, [locationB]);
       });
     });
   }
 
   /**
-   * Asserts that the "actual" locations have all the "expected" locations and only them.
+   * 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));
   }
 
   /**
    * @return the new [Location] mock.
    */
@@ skipping 22 matching lines @@
 class _StringCodecTest {
   StringCodec codec = new StringCodec();
 
   void test_all() {
     int idA = codec.encode('aaa');
     int idB = codec.encode('bbb');
     expect(codec.decode(idA), 'aaa');
     expect(codec.decode(idB), 'bbb');
   }
 }