Make subclasses of AbstractContextTest asynchronous.

pkg/analysis_server/test/plugin/protocol_dart_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.computer.element;
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/plugin/protocol/protocol_dart.dart';
 import 'package:analyzer/dart/ast/ast.dart' as engine;
 import 'package:analyzer/dart/ast/visitor.dart' as engine;
@@ skipping 84 matching lines @@
   }
 }
 
 @reflectiveTest
 class ElementTest extends AbstractContextTest {
   engine.Element findElementInUnit(engine.CompilationUnit unit, String name,
       [engine.ElementKind kind]) {
     return findChildElement(unit.element, name, kind);
   }
 
-  void test_fromElement_CLASS() {
+  test_fromElement_CLASS() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 @deprecated
 abstract class _A {}
 class B<K, V> {}''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.ClassElement engineElement = findElementInUnit(unit, '_A');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.CLASS);
       expect(element.name, '_A');
       expect(element.typeParameters, isNull);
       {
         Location location = element.location;
         expect(location.file, '/test.dart');
@@ skipping 13 matching lines @@
       engine.ClassElement engineElement = findElementInUnit(unit, 'B');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.CLASS);
       expect(element.name, 'B');
       expect(element.typeParameters, '<K, V>');
       expect(element.flags, 0);
     }
   }
 
-  void test_fromElement_CONSTRUCTOR() {
+  test_fromElement_CONSTRUCTOR() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 class A {
   const A.myConstructor(int a, [String b]);
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.ConstructorElement engineElement =
         findElementInUnit(unit, 'myConstructor');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.CONSTRUCTOR);
     expect(element.name, 'myConstructor');
     expect(element.typeParameters, isNull);
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
@@ skipping 12 matching lines @@
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.UNKNOWN);
     expect(element.name, 'dynamic');
     expect(element.location, isNull);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
-  void test_fromElement_ENUM() {
+  test_fromElement_ENUM() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.ClassElement engineElement = findElementInUnit(unit, '_E1');
       expect(engineElement.isDeprecated, isTrue);
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM);
       expect(element.name, '_E1');
       expect(element.typeParameters, isNull);
       {
         Location location = element.location;
@@ skipping 13 matching lines @@
       engine.ClassElement engineElement = findElementInUnit(unit, 'E2');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM);
       expect(element.name, 'E2');
       expect(element.typeParameters, isNull);
       expect(element.flags, 0);
     }
   }
 
-  void test_fromElement_ENUM_CONSTANT() {
+  test_fromElement_ENUM_CONSTANT() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.FieldElement engineElement = findElementInUnit(unit, 'one');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM_CONSTANT);
       expect(element.name, 'one');
       {
         Location location = element.location;
         expect(location.file, '/test.dart');
         expect(location.offset, 23);
@@ skipping 60 matching lines @@
         expect(location.length, 'values'.length);
         expect(location.startLine, 1);
         expect(location.startColumn, 0);
       }
       expect(element.parameters, isNull);
       expect(element.returnType, 'List<E2>');
       expect(element.flags, Element.FLAG_CONST | Element.FLAG_STATIC);
     }
   }
 
-  void test_fromElement_FIELD() {
+  test_fromElement_FIELD() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 class A {
   static const myField = 42;
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.FieldElement engineElement = findElementInUnit(unit, 'myField');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.FIELD);
     expect(element.name, 'myField');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 25);
       expect(location.length, 'myField'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 16);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, 'dynamic');
     expect(element.flags, Element.FLAG_CONST | Element.FLAG_STATIC);
   }
 
-  void test_fromElement_FUNCTION_TYPE_ALIAS() {
+  test_fromElement_FUNCTION_TYPE_ALIAS() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 typedef int F<T>(String x);
 ''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.FunctionTypeAliasElement engineElement =
         findElementInUnit(unit, 'F');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
     expect(element.name, 'F');
     expect(element.typeParameters, '<T>');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 12);
       expect(location.length, 'F'.length);
       expect(location.startLine, 1);
       expect(location.startColumn, 13);
     }
     expect(element.parameters, '(String x)');
     expect(element.returnType, 'int');
     expect(element.flags, 0);
   }
 
-  void test_fromElement_GETTER() {
+  test_fromElement_GETTER() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 class A {
   String get myGetter => 42;
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'myGetter', engine.ElementKind.GETTER);
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.GETTER);
     expect(element.name, 'myGetter');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 23);
       expect(location.length, 'myGetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 14);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, 'String');
     expect(element.flags, 0);
   }
 
-  void test_fromElement_LABEL() {
+  test_fromElement_LABEL() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 main() {
 myLabel:
   while (true) {
     break myLabel;
   }
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.LabelElement engineElement = findElementInUnit(unit, 'myLabel');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.LABEL);
     expect(element.name, 'myLabel');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 9);
       expect(location.length, 'myLabel'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 1);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
-  void test_fromElement_METHOD() {
+  test_fromElement_METHOD() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 class A {
   static List<String> myMethod(int a, {String b, int c}) {
     return null;
   }
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.METHOD);
     expect(element.name, 'myMethod');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 32);
       expect(location.length, 'myGetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 23);
     }
     expect(element.parameters, '(int a, {String b, int c})');
     expect(element.returnType, 'List<String>');
     expect(element.flags, Element.FLAG_STATIC);
   }
 
-  void test_fromElement_SETTER() {
+  test_fromElement_SETTER() async {
     engine.Source source = addSource(
         '/test.dart',
         '''
 class A {
   set mySetter(String x) {}
 }''');
-    engine.CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.FieldElement engineFieldElement =
         findElementInUnit(unit, 'mySetter', engine.ElementKind.FIELD);
     engine.PropertyAccessorElement engineElement = engineFieldElement.setter;
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.SETTER);
     expect(element.name, 'mySetter');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 16);
       expect(location.length, 'mySetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 7);
     }
     expect(element.parameters, '(String x)');
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 }