Make subclasses of AbstractContextTest asynchronous.

pkg/analysis_server/test/services/search/hierarchy_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.services.src.search.hierarchy;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/search/hierarchy.dart';
@@ skipping 14 matching lines @@
 class HierarchyTest extends AbstractSingleUnitTest {
   Index index;
   SearchEngineImpl searchEngine;
 
   void setUp() {
     super.setUp();
     index = createMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
   }
 
-  void test_getClassMembers() {
-    _indexTestUnit('''
+  test_getClassMembers() async {
+    await _indexTestUnit('''
 class A {
   A() {}
   var ma1;
   ma2() {}
 }
 class B extends A {
   B() {}
   B.named() {}
   var mb1;
   mb2() {}
 }
 ''');
     {
       ClassElement classA = findElement('A');
       List<Element> members = getClassMembers(classA);
       expect(members.map((e) => e.name), unorderedEquals(['ma1', 'ma2']));
     }
     {
       ClassElement classB = findElement('B');
       List<Element> members = getClassMembers(classB);
       expect(members.map((e) => e.name), unorderedEquals(['mb1', 'mb2']));
     }
   }
 
-  Future test_getHierarchyMembers_constructors() {
-    _indexTestUnit('''
+  test_getHierarchyMembers_constructors() async {
+    await _indexTestUnit('''
 class A {
   A() {}
 }
 class B extends A {
   B() {}
 }
 ''');
     ClassElement classA = findElement("A");
     ClassElement classB = findElement("B");
     ClassMemberElement memberA = classA.constructors[0];
     ClassMemberElement memberB = classB.constructors[0];
     var futureA = getHierarchyMembers(searchEngine, memberA).then((members) {
       expect(members, unorderedEquals([memberA]));
     });
     var futureB = getHierarchyMembers(searchEngine, memberB).then((members) {
       expect(members, unorderedEquals([memberB]));
     });
     return Future.wait([futureA, futureB]);
   }
 
-  Future test_getHierarchyMembers_fields() {
-    _indexTestUnit('''
+  test_getHierarchyMembers_fields() async {
+    await _indexTestUnit('''
 class A {
   int foo;
 }
 class B extends A {
   get foo => null;
 }
 class C extends B {
   set foo(x) {}
 }
 class D {
@@ skipping 16 matching lines @@
     });
     var futureC = getHierarchyMembers(searchEngine, memberC).then((members) {
       expect(members, unorderedEquals([memberA, memberB, memberC]));
     });
     var futureD = getHierarchyMembers(searchEngine, memberD).then((members) {
       expect(members, unorderedEquals([memberD]));
     });
     return Future.wait([futureA, futureB, futureC, futureD]);
   }
 
-  Future test_getHierarchyMembers_fields_static() async {
-    _indexTestUnit('''
+  test_getHierarchyMembers_fields_static() async {
+    await _indexTestUnit('''
 class A {
   static int foo;
 }
 class B extends A {
   static get foo => null;
 }
 class C extends B {
   static set foo(x) {}
 }
 ''');
@@ skipping 13 matching lines @@
           await getHierarchyMembers(searchEngine, memberB);
       expect(members, unorderedEquals([memberB]));
     }
     {
       Set<ClassMemberElement> members =
           await getHierarchyMembers(searchEngine, memberC);
       expect(members, unorderedEquals([memberC]));
     }
   }
 
-  Future test_getHierarchyMembers_methods() {
-    _indexTestUnit('''
+  test_getHierarchyMembers_methods() async {
+    await _indexTestUnit('''
 class A {
   foo() {}
 }
 class B extends A {
   foo() {}
 }
 class C extends B {
   foo() {}
 }
 class D {
@@ skipping 24 matching lines @@
     });
     var futureD = getHierarchyMembers(searchEngine, memberD).then((members) {
       expect(members, unorderedEquals([memberD, memberE]));
     });
     var futureE = getHierarchyMembers(searchEngine, memberE).then((members) {
       expect(members, unorderedEquals([memberD, memberE]));
     });
     return Future.wait([futureA, futureB, futureC, futureD, futureE]);
   }
 
-  Future test_getHierarchyMembers_methods_static() async {
-    _indexTestUnit('''
+  test_getHierarchyMembers_methods_static() async {
+    await _indexTestUnit('''
 class A {
   static foo() {}
 }
 class B extends A {
   static foo() {}
 }
 ''');
     ClassElement classA = findElement('A');
     ClassElement classB = findElement('B');
     ClassMemberElement memberA = classA.methods[0];
     ClassMemberElement memberB = classB.methods[0];
     {
       Set<ClassMemberElement> members =
           await getHierarchyMembers(searchEngine, memberA);
       expect(members, unorderedEquals([memberA]));
     }
     {
       Set<ClassMemberElement> members =
           await getHierarchyMembers(searchEngine, memberB);
       expect(members, unorderedEquals([memberB]));
     }
   }
 
-  Future test_getHierarchyMembers_withInterfaces() {
-    _indexTestUnit('''
+  test_getHierarchyMembers_withInterfaces() async {
+    await _indexTestUnit('''
 class A {
   foo() {}
 }
 class B implements A {
   foo() {}
 }
 abstract class C implements A {
 }
 class D extends C {
   foo() {}
@@ skipping 13 matching lines @@
     });
     var futureB = getHierarchyMembers(searchEngine, memberB).then((members) {
       expect(members, unorderedEquals([memberA, memberB, memberD]));
     });
     var futureD = getHierarchyMembers(searchEngine, memberD).then((members) {
       expect(members, unorderedEquals([memberA, memberB, memberD]));
     });
     return Future.wait([futureA, futureB, futureD]);
   }
 
-  void test_getMembers() {
-    _indexTestUnit('''
+  test_getMembers() async {
+    await _indexTestUnit('''
 class A {
   A() {}
   var ma1;
   ma2() {}
 }
 class B extends A {
   B() {}
   B.named() {}
   var mb1;
   mb2() {}
@@ skipping 26 matching lines @@
             'ma2',
             '==',
             'toString',
             'hashCode',
             'noSuchMethod',
             'runtimeType'
           ]));
     }
   }
 
-  void test_getSuperClasses() {
-    _indexTestUnit('''
+  test_getSuperClasses() async {
+    await _indexTestUnit('''
 class A {}
 class B extends A {}
 class C extends B {}
 class D extends B implements A {}
 class M {}
 class E extends A with M {}
 class F implements A {}
 ''');
     ClassElement classA = findElement("A");
     ClassElement classB = findElement("B");
@@ skipping 32 matching lines @@
       Set<ClassElement> supers = getSuperClasses(classE);
       expect(supers, unorderedEquals([objectElement, classA]));
     }
     // F
     {
       Set<ClassElement> supers = getSuperClasses(classF);
       expect(supers, unorderedEquals([objectElement, classA]));
     }
   }
 
-  void _indexTestUnit(String code) {
-    resolveTestUnit(code);
+  Future<Null> _indexTestUnit(String code) async {
+    await resolveTestUnit(code);
     index.indexUnit(testUnit);
   }
 }