Make subclasses of AbstractContextTest asynchronous.

pkg/analysis_server/test/services/correction/assist_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.correction.assist;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/edit/assist/assist_core.dart';
 import 'package:analysis_server/plugin/protocol/protocol.dart';
@@ skipping 114 matching lines @@
 
   test_addTypeAnnotation_BAD_privateType_closureParameter() async {
     addSource(
         '/my_lib.dart',
         '''
 library my_lib;
 class A {}
 class _B extends A {}
 foo(f(_B p)) {}
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 main() {
   foo((test) {});
 }
  ''');
     await assertNoAssistAt('test)', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_BAD_privateType_declaredIdentifier() async {
     addSource(
         '/my_lib.dart',
         '''
 library my_lib;
 class A {}
 class _B extends A {}
 List<_B> getValues() => [];
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 class A<T> {
   main() {
     for (var item in getValues()) {
     }
   }
 }
 ''');
     await assertNoAssistAt('var item', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_BAD_privateType_list() async {
     addSource(
         '/my_lib.dart',
         '''
 library my_lib;
 class A {}
 class _B extends A {}
 List<_B> getValues() => [];
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 main() {
   var v = getValues();
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_BAD_privateType_variable() async {
     addSource(
         '/my_lib.dart',
         '''
 library my_lib;
 class A {}
 class _B extends A {}
 _B getValue() => new _B();
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 main() {
   var v = getValue();
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_classField_OK_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final f = 0;
 }
 ''');
     await assertHasAssistAt(
         'final ',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class A {
   final int f = 0;
 }
 ''');
   }
 
   test_addTypeAnnotation_classField_OK_int() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   var f = 0;
 }
 ''');
     await await assertHasAssistAt(
         'var ',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class A {
   int f = 0;
 }
 ''');
   }
 
   test_addTypeAnnotation_declaredIdentifier_BAD_hasTypeAnnotation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
   }
 }
 ''');
     await assertNoAssistAt('item in', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_declaredIdentifier_BAD_inForEachBody() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (var item in items) {
     42;
   }
 }
 ''');
     await assertNoAssistAt('42;', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_declaredIdentifier_BAD_unknownType() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   for (var item in unknownList) {
   }
 }
 ''');
     await assertNoAssistAt('item in', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_declaredIdentifier_generic_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A<T> {
   main(List<List<T>> items) {
     for (var item in items) {
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'item in',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class A<T> {
   main(List<List<T>> items) {
     for (List<T> item in items) {
     }
   }
 }
 ''');
   }
 
   test_addTypeAnnotation_declaredIdentifier_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (var item in items) {
   }
 }
 ''');
     // on identifier
     await assertHasAssistAt(
         'item in',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
@@ skipping 14 matching lines @@
 ''');
   }
 
   test_addTypeAnnotation_declaredIdentifier_OK_addImport_dartUri() async {
     addSource(
         '/my_lib.dart',
         r'''
 import 'dart:async';
 List<Future<int>> getFutures() => null;
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 main() {
   for (var future in getFutures()) {
   }
 }
 ''');
     await assertHasAssistAt(
         'future in',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 import 'dart:async';
 import 'my_lib.dart';
 main() {
   for (Future<int> future in getFutures()) {
   }
 }
 ''');
   }
 
   test_addTypeAnnotation_declaredIdentifier_OK_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (final item in items) {
   }
 }
 ''');
     await assertHasAssistAt(
         'item in',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main(List<String> items) {
   for (final String item in items) {
   }
 }
 ''');
   }
 
   test_addTypeAnnotation_local_BAD_hasTypeAnnotation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int v = 42;
 }
 ''');
     await assertNoAssistAt(' = 42', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_BAD_multiple() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var a = 1, b = '';
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_BAD_noValue() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_BAD_null() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = null;
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_BAD_onInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var abc = 0;
 }
 ''');
     await assertNoAssistAt('0;', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_BAD_unknown() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = unknownVar;
 }
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_local_generic_OK_literal() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   main(List<int> items) {
     var v = items;
   }
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class A {
   main(List<int> items) {
     List<int> v = items;
   }
 }
 ''');
   }
 
   test_addTypeAnnotation_local_generic_OK_local() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A<T> {
   main(List<T> items) {
     var v = items;
   }
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class A<T> {
   main(List<T> items) {
     List<T> v = items;
   }
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_addImport_dartUri() async {
     addSource(
         '/my_lib.dart',
         r'''
 import 'dart:async';
 Future<int> getFutureInt() => null;
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'my_lib.dart';
 main() {
   var v = getFutureInt();
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 import 'dart:async';
@@ skipping 69 matching lines @@
         '/aa/bbb/lib_a.dart',
         r'''
 class MyClass {}
 ''');
     addSource(
         '/ccc/lib_b.dart',
         r'''
 import '../aa/bbb/lib_a.dart';
 MyClass newMyClass() => null;
 ''');
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'ccc/lib_b.dart';
 main() {
   var v = newMyClass();
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 import 'aa/bbb/lib_a.dart';
 import 'ccc/lib_b.dart';
 main() {
   MyClass v = newMyClass();
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_Function() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = () => 1;
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main() {
   Function v = () => 1;
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_int() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 0;
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main() {
   int v = 0;
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_List() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = <String>[];
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main() {
   List<String> v = <String>[];
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_localType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class C {}
 C f() => null;
 main() {
   var x = f();
 }
 ''');
     await assertHasAssistAt(
         'x =',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class C {}
 C f() => null;
 main() {
   C x = f();
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var abc = 0;
 }
 ''');
     await assertHasAssistAt(
         'bc',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main() {
   int abc = 0;
 }
 ''');
   }
 
   test_addTypeAnnotation_local_OK_onVar() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 0;
 }
 ''');
     await assertHasAssistAt(
         'var ',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 main() {
   int v = 0;
 }
 ''');
   }
 
   test_addTypeAnnotation_OK_privateType_sameLibrary() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class _A {}
 _A getValue() => new _A();
 main() {
   var v = getValue();
 }
 ''');
     await assertHasAssistAt(
         'var ',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 class _A {}
 _A getValue() => new _A();
 main() {
   _A v = getValue();
 }
 ''');
   }
 
   test_addTypeAnnotation_parameter_BAD_hasExplicitType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 foo(f(int p)) {}
 main() {
   foo((num test) {});
 }
 ''');
     await assertNoAssistAt('test', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_parameter_BAD_noPropagatedType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 foo(f(p)) {}
 main() {
   foo((test) {});
 }
 ''');
     await assertNoAssistAt('test', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_parameter_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 foo(f(int p)) {}
 main() {
   foo((test) {});
 }
 ''');
     await assertHasAssistAt(
         'test',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 foo(f(int p)) {}
 main() {
   foo((int test) {});
 }
 ''');
   }
 
   test_addTypeAnnotation_topLevelField_BAD_multiple() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var A = 1, V = '';
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_topLevelField_BAD_noValue() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var V;
 ''');
     await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
   }
 
   test_addTypeAnnotation_topLevelField_OK_int() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var V = 0;
 ''');
     await assertHasAssistAt(
         'var ',
         DartAssistKind.ADD_TYPE_ANNOTATION,
         '''
 int V = 0;
 ''');
   }
 
   test_assignToLocalVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   List<int> bytes;
   readBytes();
 }
 List<int> readBytes() => <int>[];
 ''');
     await assertHasAssistAt(
         'readBytes();',
         DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE,
         '''
 main() {
   List<int> bytes;
   var readBytes = readBytes();
 }
 List<int> readBytes() => <int>[];
 ''');
     _assertLinkedGroup(
         change.linkedEditGroups[0],
         ['readBytes = '],
         expectedSuggestions(LinkedEditSuggestionKind.VARIABLE,
             ['list', 'bytes2', 'readBytes']));
   }
 
   test_assignToLocalVariable_alreadyAssignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var vvv;
   vvv = 42;
 }
 ''');
     await assertNoAssistAt('vvv =', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE);
   }
 
   test_assignToLocalVariable_inClosure() async {
-    resolveTestUnit(r'''
+    await resolveTestUnit(r'''
 main() {
   print(() {
     12345;
   });
 }
 ''');
     await assertHasAssistAt(
         '345',
         DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE,
         '''
 main() {
   print(() {
     var i = 12345;
   });
 }
 ''');
   }
 
   test_assignToLocalVariable_invocationArgument() async {
-    resolveTestUnit(r'''
+    await resolveTestUnit(r'''
 main() {
   f(12345);
 }
 int f(p) {}
 ''');
     await assertNoAssistAt('345', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE);
   }
 
   test_assignToLocalVariable_throw() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   throw 42;
 }
 ''');
     await assertNoAssistAt('throw ', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE);
   }
 
   test_assignToLocalVariable_void() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   f();
 }
 void f() {}
 ''');
     await assertNoAssistAt('f();', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE);
   }
 
   test_convertDocumentationIntoBlock_BAD_alreadyBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 /**
  * AAAAAAA
  */
 class A {}
 ''');
     await assertNoAssistAt(
         'AAA', DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK);
   }
 
   test_convertDocumentationIntoBlock_BAD_notDocumentation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 // AAAA
 class A {}
 ''');
     await assertNoAssistAt(
         'AAA', DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK);
   }
 
   test_convertDocumentationIntoBlock_OK_noSpaceBeforeText() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   /// AAAAA
   ///BBBBB
   ///
   /// CCCCC
   mmm() {}
 }
 ''');
     await assertHasAssistAt(
         'AAAAA',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
         '''
 class A {
   /**
    * AAAAA
    *BBBBB
    *
    * CCCCC
    */
   mmm() {}
 }
 ''');
   }
 
   test_convertDocumentationIntoBlock_OK_onReference() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 /// AAAAAAA [int] AAAAAAA
 class A {}
 ''');
     await assertHasAssistAt(
         'nt]',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
         '''
 /**
  * AAAAAAA [int] AAAAAAA
  */
 class A {}
 ''');
   }
 
   test_convertDocumentationIntoBlock_OK_onText() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   /// AAAAAAA [int] AAAAAAA
   /// BBBBBBBB BBBB BBBB
   /// CCC [A] CCCCCCCCCCC
   mmm() {}
 }
 ''');
     await assertHasAssistAt(
         'AAA [',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
         '''
 class A {
   /**
    * AAAAAAA [int] AAAAAAA
    * BBBBBBBB BBBB BBBB
    * CCC [A] CCCCCCCCCCC
    */
   mmm() {}
 }
 ''');
   }
 
   test_convertDocumentationIntoLine_BAD_alreadyLine() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 /// AAAAAAA
 class A {}
 ''');
     await assertNoAssistAt(
         'AAA', DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE);
   }
 
   test_convertDocumentationIntoLine_BAD_notDocumentation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 /* AAAA */
 class A {}
 ''');
     await assertNoAssistAt(
         'AAA', DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE);
   }
 
   test_convertDocumentationIntoLine_OK_onReference() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 /**
  * AAAAAAA [int] AAAAAAA
  */
 class A {}
 ''');
     await assertHasAssistAt(
         'nt]',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
         '''
 /// AAAAAAA [int] AAAAAAA
 class A {}
 ''');
   }
 
   test_convertDocumentationIntoLine_OK_onText() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   /**
    * AAAAAAA [int] AAAAAAA
    * BBBBBBBB BBBB BBBB
    * CCC [A] CCCCCCCCCCC
    */
   mmm() {}
 }
 ''');
     await assertHasAssistAt(
         'AAA [',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
         '''
 class A {
   /// AAAAAAA [int] AAAAAAA
   /// BBBBBBBB BBBB BBBB
   /// CCC [A] CCCCCCCCCCC
   mmm() {}
 }
 ''');
   }
 
   test_convertDocumentationIntoLine_OK_onText_hasFirstLine() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   /** AAAAAAA [int] AAAAAAA
    * BBBBBBBB BBBB BBBB
    * CCC [A] CCCCCCCCCCC
    */
   mmm() {}
 }
 ''');
     await assertHasAssistAt(
         'AAA [',
         DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
         '''
 class A {
   /// AAAAAAA [int] AAAAAAA
   /// BBBBBBBB BBBB BBBB
   /// CCC [A] CCCCCCCCCCC
   mmm() {}
 }
 ''');
   }
 
   test_convertToBlockBody_BAD_noEnclosingFunction() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var v = 123;
 ''');
     await assertNoAssistAt('v =', DartAssistKind.CONVERT_INTO_BLOCK_BODY);
   }
 
   test_convertToBlockBody_BAD_notExpressionBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   return 123;
 }
 ''');
     await assertNoAssistAt('fff() {', DartAssistKind.CONVERT_INTO_BLOCK_BODY);
   }
 
   test_convertToBlockBody_OK_async() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   mmm() async => 123;
 }
 ''');
     await assertHasAssistAt(
         'mmm()',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 class A {
   mmm() async {
     return 123;
   }
 }
 ''');
   }
 
   test_convertToBlockBody_OK_closure() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 setup(x) {}
 main() {
   setup(() => 42);
 }
 ''');
     await assertHasAssistAt(
         '() => 42',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 setup(x) {}
 main() {
   setup(() {
     return 42;
   });
 }
 ''');
     {
       Position exitPos = change.selection;
       expect(exitPos, isNotNull);
       expect(exitPos.file, testFile);
       expect(exitPos.offset - 3, resultCode.indexOf('42;'));
     }
   }
 
   test_convertToBlockBody_OK_closure_voidExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 setup(x) {}
 main() {
   setup(() => print('done'));
 }
 ''');
     await assertHasAssistAt(
         '() => print',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 setup(x) {}
 main() {
   setup(() {
     print('done');
   });
 }
 ''');
     {
       Position exitPos = change.selection;
       expect(exitPos, isNotNull);
       expect(exitPos.file, testFile);
       expect(exitPos.offset - 3, resultCode.indexOf("');"));
     }
   }
 
   test_convertToBlockBody_OK_constructor() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   factory A() => null;
 }
 ''');
     await assertHasAssistAt(
         'A()',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 class A {
   factory A() {
     return null;
   }
 }
 ''');
   }
 
   test_convertToBlockBody_OK_method() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   mmm() => 123;
 }
 ''');
     await assertHasAssistAt(
         'mmm()',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 class A {
   mmm() {
     return 123;
   }
 }
 ''');
   }
 
   test_convertToBlockBody_OK_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() => 123;
 ''');
     await assertHasAssistAt(
         'fff()',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 fff() {
   return 123;
 }
 ''');
   }
 
   test_convertToBlockBody_OK_onValue() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() => 123;
 ''');
     await assertHasAssistAt(
         '23;',
         DartAssistKind.CONVERT_INTO_BLOCK_BODY,
         '''
 fff() {
   return 123;
 }
 ''');
   }
 
   test_convertToExpressionBody_BAD_already() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() => 42;
 ''');
     await assertNoAssistAt(
         'fff()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY);
   }
 
   test_convertToExpressionBody_BAD_moreThanOneStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   var v = 42;
   return v;
 }
 ''');
     await assertNoAssistAt(
         'fff()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY);
   }
 
   test_convertToExpressionBody_BAD_noEnclosingFunction() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var V = 42;
 ''');
     await assertNoAssistAt('V = ', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY);
   }
 
   test_convertToExpressionBody_BAD_noReturn() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   var v = 42;
 }
 ''');
     await assertNoAssistAt(
         'fff()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY);
   }
 
   test_convertToExpressionBody_BAD_noReturnValue() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   return;
 }
 ''');
     await assertNoAssistAt(
         'fff()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY);
   }
 
   test_convertToExpressionBody_OK_async() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   mmm() async {
     return 42;
   }
 }
 ''');
     await assertHasAssistAt(
         'mmm',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 class A {
   mmm() async => 42;
 }
 ''');
   }
 
   test_convertToExpressionBody_OK_closure() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 setup(x) {}
 main() {
   setup(() {
     return 42;
   });
 }
 ''');
     await assertHasAssistAt(
         '42;',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 setup(x) {}
 main() {
   setup(() => 42);
 }
 ''');
   }
 
   test_convertToExpressionBody_OK_closure_voidExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 setup(x) {}
 main() {
   setup(() {
     print('test');
   });
 }
 ''');
     await assertHasAssistAt(
         'print(',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 setup(x) {}
 main() {
   setup(() => print('test'));
 }
 ''');
   }
 
   test_convertToExpressionBody_OK_constructor() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   factory A() {
     return null;
   }
 }
 ''');
     await assertHasAssistAt(
         'A()',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 class A {
   factory A() => null;
 }
 ''');
   }
 
   test_convertToExpressionBody_OK_function_onBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   return 42;
 }
 ''');
     await assertHasAssistAt(
         '{',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 fff() => 42;
 ''');
   }
 
   test_convertToExpressionBody_OK_function_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   return 42;
 }
 ''');
     await assertHasAssistAt(
         'ff()',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 fff() => 42;
 ''');
   }
 
   test_convertToExpressionBody_OK_method_onBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   m() { // marker
     return 42;
   }
 }
 ''');
     await assertHasAssistAt(
         '{ // marker',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 class A {
   m() => 42;
 }
 ''');
   }
 
   test_convertToExpressionBody_OK_topFunction_onReturnStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 fff() {
   return 42;
 }
 ''');
     await assertHasAssistAt(
         'return',
         DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 fff() => 42;
 ''');
   }
 
   test_convertToFieldParameter_BAD_additionalUse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int aaa2;
   int bbb2;
   A(int aaa) : aaa2 = aaa, bbb2 = aaa;
 }
 ''');
     await assertNoAssistAt('aaa)', DartAssistKind.CONVERT_TO_FIELD_PARAMETER);
   }
 
   test_convertToFieldParameter_BAD_notPureAssignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int aaa2;
   A(int aaa) : aaa2 = aaa * 2;
 }
 ''');
     await assertNoAssistAt('aaa)', DartAssistKind.CONVERT_TO_FIELD_PARAMETER);
   }
 
   test_convertToFieldParameter_OK_firstInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   double aaa2;
   int bbb2;
   A(int aaa, int bbb) : aaa2 = aaa, bbb2 = bbb;
 }
 ''');
     await assertHasAssistAt(
         'aaa, ',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
   double aaa2;
   int bbb2;
   A(this.aaa2, int bbb) : bbb2 = bbb;
 }
 ''');
   }
 
   test_convertToFieldParameter_OK_onParameterName_inInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int test2;
   A(int test) : test2 = test {
   }
 }
 ''');
     await assertHasAssistAt(
         'test {',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
   int test2;
   A(this.test2) {
   }
 }
 ''');
   }
 
   test_convertToFieldParameter_OK_onParameterName_inParameters() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int test;
   A(int test) : test = test {
   }
 }
 ''');
     await assertHasAssistAt(
         'test)',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
   int test;
   A(this.test) {
   }
 }
 ''');
   }
 
   test_convertToFieldParameter_OK_secondInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   double aaa2;
   int bbb2;
   A(int aaa, int bbb) : aaa2 = aaa, bbb2 = bbb;
 }
 ''');
     await assertHasAssistAt(
         'bbb)',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
   double aaa2;
   int bbb2;
   A(int aaa, this.bbb2) : aaa2 = aaa;
 }
 ''');
   }
 
   test_convertToFinalField_BAD_hasSetter_inThisClass() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo => null;
   void set foo(_) {}
 }
 ''');
     await assertNoAssistAt('get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD);
   }
 
   test_convertToFinalField_BAD_notExpressionBody() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo {
     int v = 1 + 2;
     return v + 3;
   }
 }
 ''');
     await assertNoAssistAt('get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD);
   }
 
   test_convertToFinalField_BAD_notGetter() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int foo() => 42;
 }
 ''');
     await assertNoAssistAt('foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD);
   }
 
   test_convertToFinalField_OK_blockBody_onlyReturnStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo {
     return 1 + 2;
   }
 }
 ''');
     await assertHasAssistAt(
         'get foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final int foo = 1 + 2;
 }
 ''');
   }
 
   test_convertToFinalField_OK_hasOverride() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
   int get foo => 42;
 }
 ''');
     await assertHasAssistAt(
         'get foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
   final int foo = 42;
 }
 ''');
   }
 
   test_convertToFinalField_OK_hasSetter_inSuper() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   void set foo(_) {}
 }
 class B extends A {
   int get foo => null;
 }
 ''');
     await assertHasAssistAt(
         'get foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   void set foo(_) {}
 }
 class B extends A {
   final int foo;
 }
 ''');
   }
 
   test_convertToFinalField_OK_notNull() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo => 1 + 2;
 }
 ''');
     await assertHasAssistAt(
         'get foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final int foo = 1 + 2;
 }
 ''');
   }
 
   test_convertToFinalField_OK_null() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo => null;
 }
 ''');
     await assertHasAssistAt(
         'get foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final int foo;
 }
 ''');
   }
 
   test_convertToFinalField_OK_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo => 42;
 }
 ''');
     await assertHasAssistAt(
         'foo',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final int foo = 42;
 }
 ''');
   }
 
   test_convertToFinalField_OK_onReturnType_parameterized() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   List<int> get foo => null;
 }
 ''');
     await assertHasAssistAt(
         'nt> get',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final List<int> foo;
 }
 ''');
   }
 
   test_convertToFinalField_OK_onReturnType_simple() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int get foo => 42;
 }
 ''');
     await assertHasAssistAt(
         'int get',
         DartAssistKind.CONVERT_INTO_FINAL_FIELD,
         '''
 class A {
   final int foo = 42;
 }
 ''');
   }
 
   test_convertToForIndex_BAD_bodyNotBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) print(item);
 }
 ''');
     await assertNoAssistAt(
         'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX);
   }
 
   test_convertToForIndex_BAD_doesNotDeclareVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   String item;
   for (item in items) {
     print(item);
   }
 }
 ''');
     await assertNoAssistAt('for (item', DartAssistKind.CONVERT_INTO_FOR_INDEX);
   }
 
   test_convertToForIndex_BAD_iterableIsNotVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   for (String item in ['a', 'b', 'c']) {
     print(item);
   }
 }
 ''');
     await assertNoAssistAt(
         'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX);
   }
 
   test_convertToForIndex_BAD_iterableNotList() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(Iterable<String> items) {
   for (String item in items) {
     print(item);
   }
 }
 ''');
     await assertNoAssistAt(
         'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX);
   }
 
   test_convertToForIndex_BAD_usesIJK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     print(item);
     int i, j, k;
   }
 }
 ''');
     await assertNoAssistAt(
         'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX);
   }
 
   test_convertToForIndex_OK_onDeclaredIdentifier_name() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     print(item);
   }
 }
 ''');
     await assertHasAssistAt(
         'item in',
         DartAssistKind.CONVERT_INTO_FOR_INDEX,
         '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
     print(item);
   }
 }
 ''');
   }
 
   test_convertToForIndex_OK_onDeclaredIdentifier_type() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     print(item);
   }
 }
 ''');
     await assertHasAssistAt(
         'tring item',
         DartAssistKind.CONVERT_INTO_FOR_INDEX,
         '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
     print(item);
   }
 }
 ''');
   }
 
   test_convertToForIndex_OK_onFor() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     print(item);
   }
 }
 ''');
     await assertHasAssistAt(
         'for (String',
         DartAssistKind.CONVERT_INTO_FOR_INDEX,
         '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
     print(item);
   }
 }
 ''');
   }
 
   test_convertToForIndex_OK_usesI() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     int i = 0;
   }
 }
 ''');
     await assertHasAssistAt(
         'for (String',
         DartAssistKind.CONVERT_INTO_FOR_INDEX,
         '''
 main(List<String> items) {
   for (int j = 0; j < items.length; j++) {
     String item = items[j];
     int i = 0;
   }
 }
 ''');
   }
 
   test_convertToForIndex_OK_usesIJ() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(List<String> items) {
   for (String item in items) {
     print(item);
     int i = 0, j = 1;
   }
 }
 ''');
     await assertHasAssistAt(
         'for (String',
         DartAssistKind.CONVERT_INTO_FOR_INDEX,
         '''
 main(List<String> items) {
   for (int k = 0; k < items.length; k++) {
     String item = items[k];
     print(item);
     int i = 0, j = 1;
   }
 }
 ''');
   }
 
   test_convertToGetter_BAD_noInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final int foo;
 }
 ''');
     await assertNoAssistAt('foo', DartAssistKind.CONVERT_INTO_GETTER);
   }
 
   test_convertToGetter_BAD_notFinal() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int foo = 1;
 }
 ''');
     await assertNoAssistAt('foo', DartAssistKind.CONVERT_INTO_GETTER);
   }
 
   test_convertToGetter_BAD_notSingleField() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final int foo = 1, bar = 2;
 }
 ''');
     await assertNoAssistAt('foo', DartAssistKind.CONVERT_INTO_GETTER);
   }
 
   test_convertToGetter_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
   final int foo = 1 + 2;
 }
 ''');
     await assertHasAssistAt(
         'foo =',
         DartAssistKind.CONVERT_INTO_GETTER,
         '''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
   int get foo => 1 + 2;
 }
 ''');
   }
 
   test_convertToGetter_OK_noType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final foo = 42;
 }
 ''');
     await assertHasAssistAt(
         'foo =',
         DartAssistKind.CONVERT_INTO_GETTER,
         '''
 class A {
   get foo => 42;
 }
 ''');
   }
 
   test_convertToIsNot_BAD_is_alreadyIsNot() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   p is! String;
 }
 ''');
     await assertNoAssistAt('is!', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_is_noEnclosingParenthesis() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   p is String;
 }
 ''');
     await assertNoAssistAt('is String', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_is_noPrefix() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   (p is String);
 }
 ''');
     await assertNoAssistAt('is String', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_is_notIsExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   123 + 456;
 }
 ''');
     await assertNoAssistAt('123 +', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_is_notTheNotOperator() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   ++(p is String);
 }
 ''');
     await assertNoAssistAt('is String', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_not_alreadyIsNot() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is! String);
 }
 ''');
     await assertNoAssistAt('!(p', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_not_noEnclosingParenthesis() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !p;
 }
 ''');
     await assertNoAssistAt('!p', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_not_notIsExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p == null);
 }
 ''');
     await assertNoAssistAt('!(p', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_BAD_not_notTheNotOperator() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   ++(p is String);
 }
 ''');
     await assertNoAssistAt('++(', DartAssistKind.CONVERT_INTO_IS_NOT);
   }
 
   test_convertToIsNot_OK_childOfIs_left() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is String);
 }
 ''');
     await assertHasAssistAt(
         'p is',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   p is! String;
 }
 ''');
   }
 
   test_convertToIsNot_OK_childOfIs_right() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is String);
 }
 ''');
     await assertHasAssistAt(
         'String)',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   p is! String;
 }
 ''');
   }
 
   test_convertToIsNot_OK_is() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is String);
 }
 ''');
     await assertHasAssistAt(
         'is String',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   p is! String;
 }
 ''');
   }
 
   test_convertToIsNot_OK_is_higherPrecedencePrefix() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !!(p is String);
 }
 ''');
     await assertHasAssistAt(
         'is String',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   !(p is! String);
 }
 ''');
   }
 
   test_convertToIsNot_OK_is_not_higherPrecedencePrefix() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !!(p is String);
 }
 ''');
     await assertHasAssistAt(
         '!(p',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   !(p is! String);
 }
 ''');
   }
 
   test_convertToIsNot_OK_not() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is String);
 }
 ''');
     await assertHasAssistAt(
         '!(p',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   p is! String;
 }
 ''');
   }
 
   test_convertToIsNot_OK_parentheses() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   !(p is String);
 }
 ''');
     await assertHasAssistAt(
         '(p is',
         DartAssistKind.CONVERT_INTO_IS_NOT,
         '''
 main(p) {
   p is! String;
 }
 ''');
   }
 
   test_convertToIsNotEmpty_BAD_noBang() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(String str) {
   ~str.isEmpty;
 }
 ''');
     await assertNoAssistAt(
         'isEmpty;', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY);
   }
 
   test_convertToIsNotEmpty_BAD_noIsNotEmpty() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   bool get isEmpty => false;
 }
 main(A a) {
   !a.isEmpty;
 }
 ''');
     await assertNoAssistAt(
         'isEmpty;', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY);
   }
 
   test_convertToIsNotEmpty_BAD_notInPrefixExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(String str) {
   str.isEmpty;
 }
 ''');
     await assertNoAssistAt(
         'isEmpty;', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY);
   }
 
   test_convertToIsNotEmpty_BAD_notIsEmpty() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(int p) {
   !p.isEven;
 }
 ''');
     await assertNoAssistAt('isEven;', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY);
   }
 
   test_convertToIsNotEmpty_OK_on_isEmpty() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(String str) {
   !str.isEmpty;
 }
 ''');
     await assertHasAssistAt(
         'isEmpty',
         DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
         '''
 main(String str) {
   str.isNotEmpty;
 }
 ''');
   }
 
   test_convertToIsNotEmpty_OK_on_str() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(String str) {
   !str.isEmpty;
 }
 ''');
     await assertHasAssistAt(
         'str.',
         DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
         '''
 main(String str) {
   str.isNotEmpty;
 }
 ''');
   }
 
   test_convertToIsNotEmpty_OK_propertyAccess() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(String str) {
   !'text'.isEmpty;
 }
 ''');
     await assertHasAssistAt(
         'isEmpty',
         DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
         '''
 main(String str) {
   'text'.isNotEmpty;
 }
 ''');
   }
 
   test_convertToNormalParameter_OK_dynamic() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   var test;
   A(this.test) {
   }
 }
 ''');
     await assertHasAssistAt(
         'test)',
         DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
         '''
 class A {
   var test;
   A(test) : test = test {
   }
 }
 ''');
   }
 
   test_convertToNormalParameter_OK_firstInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int test;
   A(this.test) {
   }
 }
 ''');
     await assertHasAssistAt(
         'test)',
         DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
         '''
 class A {
   int test;
   A(int test) : test = test {
   }
 }
 ''');
   }
 
   test_convertToNormalParameter_OK_secondInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   double aaa;
   int bbb;
   A(this.bbb) : aaa = 1.0;
 }
 ''');
     await assertHasAssistAt(
         'bbb)',
         DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
         '''
 class A {
   double aaa;
   int bbb;
   A(int bbb) : aaa = 1.0, bbb = bbb;
 }
 ''');
   }
 
   test_encapsulateField_BAD_alreadyPrivate() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int _test = 42;
 }
 main(A a) {
   print(a._test);
 }
 ''');
     await assertNoAssistAt('_test =', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_BAD_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final int test = 42;
 }
 ''');
     await assertNoAssistAt('test =', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_BAD_multipleFields() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int aaa, bbb, ccc;
 }
 main(A a) {
   print(a.bbb);
 }
 ''');
     await assertNoAssistAt('bbb, ', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_BAD_notOnName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int test = 1 + 2 + 3;
 }
 ''');
     await assertNoAssistAt('+ 2', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_BAD_parseError() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int; // marker
 }
 main(A a) {
   print(a.test);
 }
 ''');
     await assertNoAssistAt('; // marker', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_BAD_static() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   static int test = 42;
 }
 ''');
     await assertNoAssistAt('test =', DartAssistKind.ENCAPSULATE_FIELD);
   }
 
   test_encapsulateField_OK_hasType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int test = 42;
   A(this.test);
 }
 main(A a) {
   print(a.test);
 }
 ''');
     await assertHasAssistAt(
         'test = 42',
         DartAssistKind.ENCAPSULATE_FIELD,
         '''
 class A {
   int _test = 42;
 
   int get test => _test;
 
   void set test(int test) {
     _test = test;
   }
   A(this._test);
 }
 main(A a) {
   print(a.test);
 }
 ''');
   }
 
   test_encapsulateField_OK_noType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   var test = 42;
 }
 main(A a) {
   print(a.test);
 }
 ''');
     await assertHasAssistAt(
         'test = 42',
         DartAssistKind.ENCAPSULATE_FIELD,
         '''
 class A {
   var _test = 42;
 
   get test => _test;
 
   void set test(test) {
     _test = test;
   }
 }
 main(A a) {
   print(a.test);
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_BAD_extraLength() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   111 + 222;
 }
 ''');
     length = 3;
     await assertNoAssistAt('+ 222', DartAssistKind.EXCHANGE_OPERANDS);
   }
 
   test_exchangeBinaryExpressionArguments_BAD_onOperand() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   111 + 222;
 }
 ''');
     length = 3;
     await assertNoAssistAt('11 +', DartAssistKind.EXCHANGE_OPERANDS);
   }
 
   test_exchangeBinaryExpressionArguments_BAD_selectionWithBinary() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     length = '1 + 2 + 3'.length;
     await assertNoAssistAt('1 + 2 + 3', DartAssistKind.EXCHANGE_OPERANDS);
   }
 
   test_exchangeBinaryExpressionArguments_OK_compare() async {
     const initialOperators = const ['<', '<=', '>', '>='];
     const resultOperators = const ['>', '>=', '<', '<='];
     for (int i = 0; i <= 0; i++) {
       String initialOperator = initialOperators[i];
       String resultOperator = resultOperators[i];
-      resolveTestUnit('''
+      await resolveTestUnit('''
 bool main(int a, int b) {
   return a $initialOperator b;
 }
 ''');
       await assertHasAssistAt(
           initialOperator,
           DartAssistKind.EXCHANGE_OPERANDS,
           '''
 bool main(int a, int b) {
   return b $resultOperator a;
 }
 ''');
     }
   }
 
   test_exchangeBinaryExpressionArguments_OK_extended_mixOperator_1() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 * 2 * 3 + 4;
 }
 ''');
     await assertHasAssistAt(
         '* 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 * 3 * 1 + 4;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_extended_mixOperator_2() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2 - 3 + 4;
 }
 ''');
     await assertHasAssistAt(
         '+ 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 1 - 3 + 4;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterFirst() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     await assertHasAssistAt(
         '+ 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 3 + 1;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterSecond() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     await assertHasAssistAt(
         '+ 3',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   3 + 1 + 2;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_simple_afterOperator() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2;
 }
 ''');
     await assertHasAssistAt(
         ' 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 1;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_simple_beforeOperator() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2;
 }
 ''');
     await assertHasAssistAt(
         '+ 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 1;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_simple_fullSelection() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2;
 }
 ''');
     length = '1 + 2'.length;
     await assertHasAssistAt(
         '1 + 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 1;
 }
 ''');
   }
 
   test_exchangeBinaryExpressionArguments_OK_simple_withLength() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   1 + 2;
 }
 ''');
     length = 2;
     await assertHasAssistAt(
         '+ 2',
         DartAssistKind.EXCHANGE_OPERANDS,
         '''
 main() {
   2 + 1;
 }
 ''');
   }
 
   test_importAddShow_BAD_hasShow() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'dart:math' show PI;
 main() {
   PI;
 }
 ''');
     await assertNoAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW);
   }
 
   test_importAddShow_BAD_unresolvedUri() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import '/no/such/lib.dart';
 ''');
     await assertNoAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW);
   }
 
   test_importAddShow_BAD_unused() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'dart:math';
 ''');
     await assertNoAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW);
   }
 
   test_importAddShow_OK_hasUnresolvedIdentifier() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'dart:math';
 main(x) {
   PI;
   return x.foo();
 }
 ''');
     await assertHasAssistAt(
         'import ',
         DartAssistKind.IMPORT_ADD_SHOW,
         '''
 import 'dart:math' show PI;
 main(x) {
   PI;
   return x.foo();
 }
 ''');
   }
 
   test_importAddShow_OK_onDirective() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'dart:math';
 main() {
   PI;
   E;
   max(1, 2);
 }
 ''');
     await assertHasAssistAt(
         'import ',
         DartAssistKind.IMPORT_ADD_SHOW,
         '''
 import 'dart:math' show E, PI, max;
 main() {
   PI;
   E;
   max(1, 2);
 }
 ''');
   }
 
   test_importAddShow_OK_onUri() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 import 'dart:math';
 main() {
   PI;
   E;
   max(1, 2);
 }
 ''');
     await assertHasAssistAt(
         'art:math',
         DartAssistKind.IMPORT_ADD_SHOW,
         '''
 import 'dart:math' show E, PI, max;
 main() {
   PI;
   E;
   max(1, 2);
 }
 ''');
   }
 
   test_introduceLocalTestedType_BAD_notBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   if (p is String)
     print('not a block');
 }
 ''');
     await assertNoAssistAt('if (p', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE);
   }
 
   test_introduceLocalTestedType_BAD_notIsExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   if (p == null) {
   }
 }
 ''');
     await assertNoAssistAt('if (p', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE);
   }
 
   test_introduceLocalTestedType_BAD_notStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class C {
   bool b;
   C(v) : b = v is int;
 }''');
     await assertNoAssistAt('is int', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE);
   }
 
   test_introduceLocalTestedType_OK_if_is() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class MyTypeName {}
 main(p) {
   if (p is MyTypeName) {
   }
   p = null;
 }
 ''');
     String expected = '''
 class MyTypeName {}
 main(p) {
   if (p is MyTypeName) {
     MyTypeName myTypeName = p;
   }
   p = null;
 }
 ''';
     await assertHasAssistAt(
         'is MyType', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
     _assertLinkedGroup(
         change.linkedEditGroups[0],
         ['myTypeName = '],
         expectedSuggestions(LinkedEditSuggestionKind.VARIABLE,
             ['myTypeName', 'typeName', 'name']));
     // another good location
     await assertHasAssistAt(
         'if (p', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
   }
 
   test_introduceLocalTestedType_OK_if_isNot() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class MyTypeName {}
 main(p) {
   if (p is! MyTypeName) {
     return;
   }
 }
 ''');
     String expected = '''
 class MyTypeName {}
 main(p) {
   if (p is! MyTypeName) {
     return;
   }
   MyTypeName myTypeName = p;
 }
 ''';
     await assertHasAssistAt(
         'is! MyType', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
     _assertLinkedGroup(
         change.linkedEditGroups[0],
         ['myTypeName = '],
         expectedSuggestions(LinkedEditSuggestionKind.VARIABLE,
             ['myTypeName', 'typeName', 'name']));
     // another good location
     await assertHasAssistAt(
         'if (p', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
   }
 
   test_introduceLocalTestedType_OK_while() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(p) {
   while (p is String) {
   }
   p = null;
 }
 ''');
     String expected = '''
 main(p) {
   while (p is String) {
     String s = p;
   }
   p = null;
 }
 ''';
     await assertHasAssistAt(
         'is String', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
     await assertHasAssistAt(
         'while (p', DartAssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
   }
 
   test_invalidSelection() async {
-    resolveTestUnit('');
+    await resolveTestUnit('');
     List<Assist> assists = await computeAssists(plugin, context,
         resolutionMap.elementDeclaredByCompilationUnit(testUnit).source, -1, 0);
     expect(assists, isEmpty);
   }
 
   test_invertIfStatement_blocks() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true) {
     0;
   } else {
     1;
   }
 }
 ''');
     await assertHasAssistAt(
         'if (',
         DartAssistKind.INVERT_IF_STATEMENT,
         '''
 main() {
   if (false) {
     1;
   } else {
     0;
   }
 }
 ''');
   }
 
   test_invertIfStatement_statements() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true)
     0;
   else
     1;
 }
 ''');
     await assertHasAssistAt(
         'if (',
         DartAssistKind.INVERT_IF_STATEMENT,
         '''
 main() {
   if (false)
     1;
   else
     0;
 }
 ''');
   }
 
   test_joinIfStatementInner_BAD_innerNotIf() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     print(0);
   }
 }
 ''');
     await assertNoAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_BAD_innerWithElse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     } else {
       print(1);
     }
   }
 }
 ''');
     await assertNoAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_BAD_statementAfterInner() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(2);
     }
     print(1);
   }
 }
 ''');
     await assertNoAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_BAD_statementBeforeInner() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     print(1);
     if (2 == 2) {
       print(2);
     }
   }
 }
 ''');
     await assertNoAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_BAD_targetNotIf() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   print(0);
 }
 ''');
     await assertNoAssistAt('print', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_BAD_targetWithElse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   } else {
     print(1);
   }
 }
 ''');
     await assertNoAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER);
   }
 
   test_joinIfStatementInner_OK_conditionAndOr() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2 || 3 == 3) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && (2 == 2 || 3 == 3)) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_conditionInvocation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (isCheck()) {
     if (2 == 2) {
       print(0);
     }
   }
 }
 bool isCheck() => false;
 ''');
     await assertHasAssistAt(
         'if (isCheck',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (isCheck() && 2 == 2) {
     print(0);
   }
 }
 bool isCheck() => false;
 ''');
   }
 
   test_joinIfStatementInner_OK_conditionOrAnd() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 || 2 == 2) {
     if (3 == 3) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if ((1 == 1 || 2 == 2) && 3 == 3) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_onCondition() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         '1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_simpleConditions_block_block() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_simpleConditions_block_single() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2)
       print(0);
   }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_simpleConditions_single_blockMulti() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(1);
       print(2);
       print(3);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(1);
     print(2);
     print(3);
   }
 }
 ''');
   }
 
   test_joinIfStatementInner_OK_simpleConditions_single_blockOne() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1)
     if (2 == 2) {
       print(0);
     }
 }
 ''');
     await assertHasAssistAt(
         'if (1 ==',
         DartAssistKind.JOIN_IF_WITH_INNER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_BAD_outerNotIf() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     print(0);
   }
 }
 ''');
     await assertNoAssistAt('if (1 == 1', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_BAD_outerWithElse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   } else {
     print(1);
   }
 }
 ''');
     await assertNoAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_BAD_statementAfterInner() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(2);
     }
     print(1);
   }
 }
 ''');
     await assertNoAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_BAD_statementBeforeInner() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     print(1);
     if (2 == 2) {
       print(2);
     }
   }
 }
 ''');
     await assertNoAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_BAD_targetNotIf() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   print(0);
 }
 ''');
     await assertNoAssistAt('print', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_BAD_targetWithElse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     } else {
       print(1);
     }
   }
 }
 ''');
     await assertNoAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER);
   }
 
   test_joinIfStatementOuter_OK_conditionAndOr() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2 || 3 == 3) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (2 ==',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && (2 == 2 || 3 == 3)) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_conditionInvocation() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (isCheck()) {
       print(0);
     }
   }
 }
 bool isCheck() => false;
 ''');
     await assertHasAssistAt(
         'if (isCheck',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && isCheck()) {
     print(0);
   }
 }
 bool isCheck() => false;
 ''');
   }
 
   test_joinIfStatementOuter_OK_conditionOrAnd() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 || 2 == 2) {
     if (3 == 3) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (3 == 3',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if ((1 == 1 || 2 == 2) && 3 == 3) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_onCondition() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (2 == 2',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_simpleConditions_block_block() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(0);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (2 == 2',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_simpleConditions_block_single() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2)
       print(0);
   }
 }
 ''');
     await assertHasAssistAt(
         'if (2 == 2',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_simpleConditions_single_blockMulti() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1) {
     if (2 == 2) {
       print(1);
       print(2);
       print(3);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         'if (2 == 2',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(1);
     print(2);
     print(3);
   }
 }
 ''');
   }
 
   test_joinIfStatementOuter_OK_simpleConditions_single_blockOne() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1)
     if (2 == 2) {
       print(0);
     }
 }
 ''');
     await assertHasAssistAt(
         'if (2 == 2',
         DartAssistKind.JOIN_IF_WITH_OUTER,
         '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
 }
 ''');
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_hasInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 1;
   v = 2;
 }
 ''');
     await assertNoAssistAt('v = 2', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notAdjacent() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   var bar;
   v = 1;
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notAssignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v += 1;
 }
 ''');
     await assertNoAssistAt('v += 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notDeclaration() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main(var v) {
   v = 1;
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notLeftArgument() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   1 + v; // marker
 }
 ''');
     await assertNoAssistAt(
         'v; // marker', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notOneVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v, v2;
   v = 1;
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notResolved() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   x = 1;
 }
 ''');
     await assertNoAssistAt('x = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_BAD_notSameBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   {
     v = 1;
   }
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onAssignment_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v = 1;
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.JOIN_VARIABLE_DECLARATION,
         '''
 main() {
   var v = 1;
 }
 ''');
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_hasInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 1;
   v = 2;
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_lastStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true)
     var v;
 }
 ''');
     await assertNoAssistAt('v;', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_nextNotAssignmentExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   42;
 }
 ''');
     await assertNoAssistAt('v;', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_nextNotExpressionStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   if (true) return;
 }
 ''');
     await assertNoAssistAt('v;', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_nextNotPureAssignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v += 1;
 }
 ''');
     await assertNoAssistAt('v;', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_BAD_notOneVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v, v2;
   v = 1;
 }
 ''');
     await assertNoAssistAt('v, ', DartAssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   test_joinVariableDeclaration_onDeclaration_OK_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v = 1;
 }
 ''');
     await assertHasAssistAt(
         'v;',
         DartAssistKind.JOIN_VARIABLE_DECLARATION,
         '''
 main() {
   var v = 1;
 }
 ''');
   }
 
   test_joinVariableDeclaration_onDeclaration_OK_onType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int v;
   v = 1;
 }
 ''');
     await assertHasAssistAt(
         'int v',
         DartAssistKind.JOIN_VARIABLE_DECLARATION,
         '''
 main() {
   int v = 1;
 }
 ''');
   }
 
   test_joinVariableDeclaration_onDeclaration_OK_onVar() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v = 1;
 }
 ''');
     await assertHasAssistAt(
         'var v',
         DartAssistKind.JOIN_VARIABLE_DECLARATION,
         '''
 main() {
   var v = 1;
 }
 ''');
   }
 
   test_removeTypeAnnotation_classField_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   int v = 1;
 }
 ''');
     await assertHasAssistAt(
         'v = ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 class A {
   var v = 1;
 }
 ''');
   }
 
   test_removeTypeAnnotation_classField_OK_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 class A {
   final int v = 1;
 }
 ''');
     await assertHasAssistAt(
         'v = ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 class A {
   final v = 1;
 }
 ''');
   }
 
   test_removeTypeAnnotation_localVariable_BAD_onInitializer() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   final int v = 1;
 }
 ''');
     await assertNoAssistAt('1;', DartAssistKind.REMOVE_TYPE_ANNOTATION);
   }
 
   test_removeTypeAnnotation_localVariable_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int a = 1, b = 2;
 }
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 main() {
   var a = 1, b = 2;
 }
 ''');
   }
 
   test_removeTypeAnnotation_localVariable_OK_const() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   const int v = 1;
 }
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 main() {
   const v = 1;
 }
 ''');
   }
 
   test_removeTypeAnnotation_localVariable_OK_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   final int v = 1;
 }
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 main() {
   final v = 1;
 }
 ''');
   }
 
   test_removeTypeAnnotation_topLevelVariable_BAD_syntheticName() async {
     verifyNoTestUnitErrors = false;
-    resolveTestUnit('''
+    await resolveTestUnit('''
 MyType
 ''');
     await assertNoAssistAt('MyType', DartAssistKind.REMOVE_TYPE_ANNOTATION);
   }
 
   test_removeTypeAnnotation_topLevelVariable_OK() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 int V = 1;
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 var V = 1;
 ''');
   }
 
   test_removeTypeAnnotation_topLevelVariable_OK_final() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 final int V = 1;
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.REMOVE_TYPE_ANNOTATION,
         '''
 final V = 1;
 ''');
   }
 
   test_replaceConditionalWithIfElse_BAD_noEnclosingStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 var v = true ? 111 : 222;
 ''');
     await assertNoAssistAt(
         '? 111', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE);
   }
 
   test_replaceConditionalWithIfElse_BAD_notConditional() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 42;
 }
 ''');
     await assertNoAssistAt(
         'v = 42', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE);
   }
 
   test_replaceConditionalWithIfElse_OK_assignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v;
   v = true ? 111 : 222;
 }
 ''');
     // on conditional
     await assertHasAssistAt(
         '11 :',
         DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
         '''
@@ skipping 16 matching lines @@
   if (true) {
     v = 111;
   } else {
     v = 222;
   }
 }
 ''');
   }
 
   test_replaceConditionalWithIfElse_OK_return() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   return true ? 111 : 222;
 }
 ''');
     await assertHasAssistAt(
         'return ',
         DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
         '''
 main() {
   if (true) {
     return 111;
   } else {
     return 222;
   }
 }
 ''');
   }
 
   test_replaceConditionalWithIfElse_OK_variableDeclaration() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int a = 1, vvv = true ? 111 : 222, b = 2;
 }
 ''');
     await assertHasAssistAt(
         '11 :',
         DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
         '''
 main() {
   int a = 1, vvv, b = 2;
   if (true) {
     vvv = 111;
   } else {
     vvv = 222;
   }
 }
 ''');
   }
 
   test_replaceIfElseWithConditional_BAD_expressionVsReturn() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true) {
     print(42);
   } else {
     return;
   }
 }
 ''');
     await assertNoAssistAt(
         'else', DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL);
   }
 
   test_replaceIfElseWithConditional_BAD_notIfStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   print(0);
 }
 ''');
     await assertNoAssistAt(
         'print', DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL);
   }
 
   test_replaceIfElseWithConditional_BAD_notSingleStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int vvv;
   if (true) {
     print(0);
     vvv = 111;
   } else {
     print(0);
     vvv = 222;
   }
 }
 ''');
     await assertNoAssistAt(
         'if (true)', DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL);
   }
 
   test_replaceIfElseWithConditional_OK_assignment() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int vvv;
   if (true) {
     vvv = 111;
   } else {
     vvv = 222;
   }
 }
 ''');
     await assertHasAssistAt(
         'if (true)',
         DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
         '''
 main() {
   int vvv;
   vvv = true ? 111 : 222;
 }
 ''');
   }
 
   test_replaceIfElseWithConditional_OK_return() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true) {
     return 111;
   } else {
     return 222;
   }
 }
 ''');
     await assertHasAssistAt(
         'if (true)',
         DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
         '''
 main() {
   return true ? 111 : 222;
 }
 ''');
   }
 
   test_splitAndCondition_BAD_hasElse() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 && 2 == 2) {
     print(1);
   } else {
     print(2);
   }
 }
 ''');
     await assertNoAssistAt('&& 2', DartAssistKind.SPLIT_AND_CONDITION);
   }
 
   test_splitAndCondition_BAD_notAnd() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 || 2 == 2) {
     print(0);
   }
 }
 ''');
     await assertNoAssistAt('|| 2', DartAssistKind.SPLIT_AND_CONDITION);
   }
 
   test_splitAndCondition_BAD_notPartOfIf() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   print(1 == 1 && 2 == 2);
 }
 ''');
     await assertNoAssistAt('&& 2', DartAssistKind.SPLIT_AND_CONDITION);
   }
 
   test_splitAndCondition_BAD_notTopLevelAnd() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true || (1 == 1 && 2 == 2)) {
     print(0);
   }
   if (true && (3 == 3 && 4 == 4)) {
     print(0);
   }
 }
 ''');
     await assertNoAssistAt('&& 2', DartAssistKind.SPLIT_AND_CONDITION);
     await assertNoAssistAt('&& 4', DartAssistKind.SPLIT_AND_CONDITION);
   }
 
   test_splitAndCondition_OK_innerAndExpression() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 && 2 == 2 && 3 == 3) {
     print(0);
   }
 }
 ''');
     await assertHasAssistAt(
         '&& 2 == 2',
         DartAssistKind.SPLIT_AND_CONDITION,
         '''
 main() {
   if (1 == 1) {
     if (2 == 2 && 3 == 3) {
       print(0);
     }
   }
 }
 ''');
   }
 
   test_splitAndCondition_OK_thenBlock() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true && false) {
     print(0);
     if (3 == 3) {
       print(1);
     }
   }
 }
 ''');
     await assertHasAssistAt(
         '&& false',
         DartAssistKind.SPLIT_AND_CONDITION,
         '''
 main() {
   if (true) {
     if (false) {
       print(0);
       if (3 == 3) {
         print(1);
       }
     }
   }
 }
 ''');
   }
 
   test_splitAndCondition_OK_thenStatement() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (true && false)
     print(0);
 }
 ''');
     await assertHasAssistAt(
         '&& false',
         DartAssistKind.SPLIT_AND_CONDITION,
         '''
 main() {
   if (true)
     if (false)
       print(0);
 }
 ''');
   }
 
   test_splitAndCondition_wrong() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
   }
   print(3 == 3 && 4 == 4);
 }
 ''');
     // not binary expression
     await assertNoAssistAt('main() {', DartAssistKind.SPLIT_AND_CONDITION);
     // selection is not empty and includes more than just operator
     {
       length = 5;
       await assertNoAssistAt('&& 2 == 2', DartAssistKind.SPLIT_AND_CONDITION);
     }
   }
 
   test_splitVariableDeclaration_BAD_notOneVariable() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 1, v2;
 }
 ''');
     await assertNoAssistAt('v = 1', DartAssistKind.SPLIT_VARIABLE_DECLARATION);
   }
 
   test_splitVariableDeclaration_OK_onName() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 1;
 }
 ''');
     await assertHasAssistAt(
         'v =',
         DartAssistKind.SPLIT_VARIABLE_DECLARATION,
         '''
 main() {
   var v;
   v = 1;
 }
 ''');
   }
 
   test_splitVariableDeclaration_OK_onType() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   int v = 1;
 }
 ''');
     await assertHasAssistAt(
         'int ',
         DartAssistKind.SPLIT_VARIABLE_DECLARATION,
         '''
 main() {
   int v;
   v = 1;
 }
 ''');
   }
 
   test_splitVariableDeclaration_OK_onVar() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
   var v = 1;
 }
 ''');
     await assertHasAssistAt(
         'var ',
         DartAssistKind.SPLIT_VARIABLE_DECLARATION,
         '''
 main() {
   var v;
   v = 1;
 }
 ''');
   }
 
   test_surroundWith_block() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_BLOCK,
         '''
 main() {
 // start
   {
     print(0);
     print(1);
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_doWhile() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_DO_WHILE,
         '''
 main() {
 // start
   do {
     print(0);
     print(1);
   } while (condition);
 // end
 }
 ''');
   }
 
   test_surroundWith_for() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_FOR,
         '''
 main() {
 // start
   for (var v = init; condition; increment) {
     print(0);
     print(1);
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_forIn() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_FOR_IN,
         '''
 main() {
 // start
   for (var item in iterable) {
     print(0);
     print(1);
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_if() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_IF,
         '''
 main() {
 // start
   if (condition) {
     print(0);
     print(1);
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_tryCatch() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_TRY_CATCH,
         '''
 main() {
 // start
   try {
     print(0);
     print(1);
   } on Exception catch (e) {
     // TODO
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_tryFinally() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_TRY_FINALLY,
         '''
 main() {
 // start
   try {
     print(0);
     print(1);
   } finally {
     // TODO
   }
 // end
 }
 ''');
   }
 
   test_surroundWith_while() async {
-    resolveTestUnit('''
+    await resolveTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _setStartEndSelection();
     await assertHasAssist(
         DartAssistKind.SURROUND_WITH_WHILE,
@@ skipping 43 matching lines @@
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _setStartEndSelection() {
     offset = findOffset('// start\n') + '// start\n'.length;
     length = findOffset('// end') - offset;
   }
 }