Make subclasses of AbstractContextTest asynchronous.

pkg/analysis_server/test/services/refactoring/extract_method_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.refactoring.extract_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/refactoring/extract_method.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'abstract_refactoring.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ExtractMethodTest);
   });
 }
 
 @reflectiveTest
 class ExtractMethodTest extends RefactoringTest {
   ExtractMethodRefactoringImpl refactoring;
 
-  test_bad_assignmentLeftHandSide() {
-    indexTestUnit('''
+  test_bad_assignmentLeftHandSide() async {
+    await indexTestUnit('''
 main() {
   int aaa;
   aaa = 0;
 }
 ''');
     _createRefactoringForString('aaa ');
     return _assertConditionsFatal(
         'Cannot extract the left-hand side of an assignment.');
   }
 
-  test_bad_comment_selectionEndsInside() {
-    indexTestUnit('''
+  test_bad_comment_selectionEndsInside() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0);
 /*
 // end
 */
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal('Selection ends inside a comment.');
   }
 
-  test_bad_comment_selectionStartsInside() {
-    indexTestUnit('''
+  test_bad_comment_selectionStartsInside() async {
+    await indexTestUnit('''
 main() {
 /*
 // start
 */
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal('Selection begins inside a comment.');
   }
 
-  test_bad_conflict_method_alreadyDeclaresMethod() {
-    indexTestUnit('''
+  test_bad_conflict_method_alreadyDeclaresMethod() async {
+    await indexTestUnit('''
 class A {
   void res() {}
   main() {
 // start
     print(0);
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsError(
         "Class 'A' already declares method with name 'res'.");
   }
 
-  test_bad_conflict_method_shadowsSuperDeclaration() {
-    indexTestUnit('''
+  test_bad_conflict_method_shadowsSuperDeclaration() async {
+    await indexTestUnit('''
 class A {
   void res() {} // marker
 }
 class B extends A {
   main() {
     res();
 // start
     print(0);
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsError("Created method will shadow method 'A.res'.");
   }
 
-  test_bad_conflict_topLevel_alreadyDeclaresFunction() {
-    indexTestUnit('''
+  test_bad_conflict_topLevel_alreadyDeclaresFunction() async {
+    await indexTestUnit('''
 library my.lib;
 
 void res() {}
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsError(
         "Library already declares function with name 'res'.");
   }
 
-  test_bad_conflict_topLevel_willHideInheritedMemberUsage() {
-    indexTestUnit('''
+  test_bad_conflict_topLevel_willHideInheritedMemberUsage() async {
+    await indexTestUnit('''
 class A {
   void res() {}
 }
 class B extends A {
   foo() {
     res(); // marker
   }
 }
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsError(
         "Created function will shadow method 'A.res'.");
   }
 
-  test_bad_constructor_initializer() {
-    indexTestUnit('''
+  test_bad_constructor_initializer() async {
+    await indexTestUnit('''
 class A {
   int f;
   A() : f = 0 {}
 }
 ''');
     _createRefactoringForString('f = 0');
     return _assertConditionsFatal(
         'Cannot extract a constructor initializer. Select expression part of initializer.');
   }
 
-  test_bad_constructor_redirectingConstructor() {
-    indexTestUnit('''
+  test_bad_constructor_redirectingConstructor() async {
+    await indexTestUnit('''
 class A {
   A() : this.named();
   A.named() {}
 }
 ''');
     _createRefactoringForString('this.named()');
     return _assertConditionsFatal(
         'Cannot extract a constructor initializer. Select expression part of initializer.');
   }
 
-  test_bad_constructor_superConstructor() {
-    indexTestUnit('''
+  test_bad_constructor_superConstructor() async {
+    await indexTestUnit('''
 class A {}
 class B extends A {
   B() : super();
 }
 ''');
     _createRefactoringForString('super()');
     return _assertConditionsFatal(
         'Cannot extract a constructor initializer. Select expression part of initializer.');
   }
 
-  test_bad_doWhile_body() {
-    indexTestUnit('''
+  test_bad_doWhile_body() async {
+    await indexTestUnit('''
 main() {
   do
 // start
   {
   }
 // end
   while (true);
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Operation not applicable to a 'do' statement's body and expression.");
   }
 
-  test_bad_emptySelection() {
-    indexTestUnit('''
+  test_bad_emptySelection() async {
+    await indexTestUnit('''
 main() {
 // start
 // end
   print(0);
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Can only extract a single expression or a set of statements.");
   }
 
-  test_bad_forLoop_conditionAndUpdaters() {
-    indexTestUnit('''
+  test_bad_forLoop_conditionAndUpdaters() async {
+    await indexTestUnit('''
 main() {
   for (
     int i = 0;
 // start
     i < 10;
     i++
 // end
   ) {}
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Operation not applicable to a 'for' statement's condition and updaters.");
   }
 
-  test_bad_forLoop_init() {
-    indexTestUnit('''
+  test_bad_forLoop_init() async {
+    await indexTestUnit('''
 main() {
   for (
 // start
     int i = 0
 // end
     ; i < 10;
     i++
   ) {}
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Cannot extract initialization part of a 'for' statement.");
   }
 
-  test_bad_forLoop_initAndCondition() {
-    indexTestUnit('''
+  test_bad_forLoop_initAndCondition() async {
+    await indexTestUnit('''
 main() {
   for (
 // start
     int i = 0;
     i < 10;
 // end
     i++
   ) {}
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Operation not applicable to a 'for' statement's initializer and condition.");
   }
 
-  test_bad_forLoop_updaters() {
-    indexTestUnit('''
+  test_bad_forLoop_updaters() async {
+    await indexTestUnit('''
 main() {
   for (
     int i = 0;
     i < 10;
 // start
     i++
 // end
   ) {}
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Cannot extract increment part of a 'for' statement.");
   }
 
-  test_bad_forLoop_updatersAndBody() {
-    indexTestUnit('''
+  test_bad_forLoop_updatersAndBody() async {
+    await indexTestUnit('''
 main() {
   for (
     int i = 0;
     i < 10;
 // start
     i++
   ) {}
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Operation not applicable to a 'for' statement's updaters and body.");
   }
 
-  test_bad_methodName_reference() {
-    indexTestUnit('''
+  test_bad_methodName_reference() async {
+    await indexTestUnit('''
 main() {
   main();
 }
 ''');
     _createRefactoringWithSuffix('main', '();');
     return _assertConditionsFatal("Cannot extract a single method name.");
   }
 
-  test_bad_namePartOfDeclaration_function() {
-    indexTestUnit('''
+  test_bad_namePartOfDeclaration_function() async {
+    await indexTestUnit('''
 main() {
 }
 ''');
     _createRefactoringForString('main');
     return _assertConditionsFatal(
         "Cannot extract the name part of a declaration.");
   }
 
-  test_bad_namePartOfDeclaration_variable() {
-    indexTestUnit('''
+  test_bad_namePartOfDeclaration_variable() async {
+    await indexTestUnit('''
 main() {
   int vvv = 0;
 }
 ''');
     _createRefactoringForString('vvv');
     return _assertConditionsFatal(
         "Cannot extract the name part of a declaration.");
   }
 
-  test_bad_namePartOfQualified() {
-    indexTestUnit('''
+  test_bad_namePartOfQualified() async {
+    await indexTestUnit('''
 class A {
   var fff;
 }
 main() {
   A a;
   a.fff = 1;
 }
 ''');
     _createRefactoringWithSuffix('fff', ' = 1');
     return _assertConditionsFatal(
         "Can not extract name part of a property access.");
   }
 
-  test_bad_newMethodName_notIdentifier() {
-    indexTestUnit('''
+  test_bad_newMethodName_notIdentifier() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     refactoring.name = 'bad-name';
     // check conditions
     return _assertConditionsFatal("Method name must not contain '-'.");
   }
 
-  test_bad_notSameParent() {
-    indexTestUnit('''
+  test_bad_notSameParent() async {
+    await indexTestUnit('''
 main() {
   while (false)
 // start
   {
   }
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         'Not all selected statements are enclosed by the same parent statement.');
   }
 
   test_bad_parameterName_duplicate() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
 // start
   int a = v1 + v2; // marker
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // update parameters
     await refactoring.checkInitialConditions();
     {
       List<RefactoringMethodParameter> parameters = _getParametersCopy();
       expect(parameters, hasLength(2));
       parameters[0].name = 'dup';
       parameters[1].name = 'dup';
       refactoring.parameters = parameters;
     }
     return _assertFinalConditionsError("Parameter 'dup' already exists");
   }
 
   test_bad_parameterName_inUse_function() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
 // start
   f(v1, v2);
 // end
 }
 f(a, b) {}
 ''');
     _createRefactoringForStartEndComments();
     // update parameters
     await refactoring.checkInitialConditions();
     {
       List<RefactoringMethodParameter> parameters = _getParametersCopy();
       expect(parameters, hasLength(2));
       parameters[0].name = 'f';
       refactoring.parameters = parameters;
     }
     return _assertFinalConditionsError(
         "'f' is already used as a name in the selected code");
   }
 
   test_bad_parameterName_inUse_localVariable() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
 // start
   int a = v1 + v2; // marker
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // update parameters
     await refactoring.checkInitialConditions();
     {
       List<RefactoringMethodParameter> parameters = _getParametersCopy();
       expect(parameters, hasLength(2));
       parameters[0].name = 'a';
       refactoring.parameters = parameters;
     }
     return _assertFinalConditionsError(
         "'a' is already used as a name in the selected code");
   }
 
   test_bad_parameterName_inUse_method() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 class A {
   main() {
     int v1 = 1;
     int v2 = 2;
   // start
     m(v1, v2);
   // end
   }
   m(a, b) {}
 }
 ''');
     _createRefactoringForStartEndComments();
     // update parameters
     await refactoring.checkInitialConditions();
     {
       List<RefactoringMethodParameter> parameters = _getParametersCopy();
       expect(parameters, hasLength(2));
       parameters[0].name = 'm';
       refactoring.parameters = parameters;
     }
     return _assertFinalConditionsError(
         "'m' is already used as a name in the selected code");
   }
 
-  test_bad_selectionEndsInSomeNode() {
-    indexTestUnit('''
+  test_bad_selectionEndsInSomeNode() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
     _createRefactoringForStartEndString('print(0', 'rint(1)');
     return _assertConditionsFatal(
         "The selection does not cover a set of statements or an expression. "
         "Extend selection to a valid range.");
   }
 
-  test_bad_statements_exit_notAllExecutionFlows() {
-    indexTestUnit('''
+  test_bad_statements_exit_notAllExecutionFlows() async {
+    await indexTestUnit('''
 main(int p) {
 // start
   if (p == 0) {
     return;
   }
 // end
   print(p);
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsError(ExtractMethodRefactoringImpl.ERROR_EXITS);
   }
 
-  test_bad_statements_return_andAssignsVariable() {
-    indexTestUnit('''
+  test_bad_statements_return_andAssignsVariable() async {
+    await indexTestUnit('''
 main() {
 // start
   var v = 0;
   return 42;
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Ambiguous return value: Selected block contains assignment(s) to "
         "local variables and return statement.");
   }
 
-  test_bad_switchCase() {
-    indexTestUnit('''
+  test_bad_switchCase() async {
+    await indexTestUnit('''
 main() {
   switch (1) {
 // start
     case 0: break;
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Selection must either cover whole switch statement "
         "or parts of a single case block.");
   }
 
-  test_bad_tokensBetweenLastNodeAndSelectionEnd() {
-    indexTestUnit('''
+  test_bad_tokensBetweenLastNodeAndSelectionEnd() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 }
 // end
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "The end of the selection contains characters that do not belong to a statement.");
   }
 
-  test_bad_tokensBetweenSelectionStartAndFirstNode() {
-    indexTestUnit('''
+  test_bad_tokensBetweenSelectionStartAndFirstNode() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0); // marker
   print(1);
 // end
 }
 ''');
     _createRefactoringForStartEndString('); // marker', '// end');
     return _assertConditionsFatal(
         "The beginning of the selection contains characters that do not belong to a statement.");
   }
 
-  test_bad_try_catchBlock_block() {
-    indexTestUnit('''
+  test_bad_try_catchBlock_block() async {
+    await indexTestUnit('''
 main() {
   try
   {}
   catch (e)
 // start
   {}
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Selection must either cover whole try statement or "
         "parts of try, catch, or finally block.");
   }
 
-  test_bad_try_catchBlock_complete() {
-    indexTestUnit('''
+  test_bad_try_catchBlock_complete() async {
+    await indexTestUnit('''
 main() {
   try
   {}
 // start
   catch (e)
   {}
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Selection must either cover whole try statement or "
         "parts of try, catch, or finally block.");
   }
 
-  test_bad_try_catchBlock_exception() {
-    indexTestUnit('''
+  test_bad_try_catchBlock_exception() async {
+    await indexTestUnit('''
 main() {
   try {
   } catch (
 // start
   e
 // end
   ) {
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         'Cannot extract the name part of a declaration.');
   }
 
-  test_bad_try_finallyBlock() {
-    indexTestUnit('''
+  test_bad_try_finallyBlock() async {
+    await indexTestUnit('''
 main() {
   try
   {}
   finally
 // start
   {}
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Selection must either cover whole try statement or "
         "parts of try, catch, or finally block.");
   }
 
-  test_bad_try_tryBlock() {
-    indexTestUnit('''
+  test_bad_try_tryBlock() async {
+    await indexTestUnit('''
 main() {
   try
 // start
   {}
 // end
   finally
   {}
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Selection must either cover whole try statement or "
         "parts of try, catch, or finally block.");
   }
 
-  test_bad_typeReference() {
-    indexTestUnit('''
+  test_bad_typeReference() async {
+    await indexTestUnit('''
 main() {
   int a = 0;
 }
 ''');
     _createRefactoringForString("int");
     return _assertConditionsFatal("Cannot extract a single type reference.");
   }
 
-  test_bad_variableDeclarationFragment() {
-    indexTestUnit('''
+  test_bad_variableDeclarationFragment() async {
+    await indexTestUnit('''
 main() {
   int
 // start
     a = 1
 // end
     ,b = 2;
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Cannot extract a variable declaration fragment. Select whole declaration statement.");
   }
 
-  test_bad_while_conditionAndBody() {
-    indexTestUnit('''
+  test_bad_while_conditionAndBody() async {
+    await indexTestUnit('''
 main() {
   while
 // start
     (false)
   {
   }
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         "Operation not applicable to a while statement's expression and body.");
   }
 
   test_canExtractGetter_false_closure() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   useFunction((_) => true);
 }
 useFunction(filter(String p)) {}
 ''');
     _createRefactoringForString('(_) => true');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, false);
     expect(refactoring.createGetter, false);
   }
 
   test_canExtractGetter_false_fieldAssignment() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 class A {
   var f;
   main() {
 // start
     f = 1;
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, false);
     expect(refactoring.createGetter, false);
   }
 
   test_canExtractGetter_false_hasParameters() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main(int p) {
   int a = p + 1;
 }
 ''');
     _createRefactoringForString('p + 1');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, false);
     expect(refactoring.createGetter, false);
   }
 
   test_canExtractGetter_false_returnNotUsed_assignment() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 var topVar = 0;
 f(int p) {
   topVar = 5;
 }
 ''');
     _createRefactoringForString('topVar = 5');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, false);
     expect(refactoring.createGetter, false);
   }
 
   test_canExtractGetter_false_returnNotUsed_noReturn() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 var topVar = 0;
 main() {
 // start
   int a = 1;
   int b = 2;
   topVar = a + b;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, false);
     expect(refactoring.createGetter, false);
   }
 
   test_canExtractGetter_true() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, true);
     expect(refactoring.createGetter, true);
   }
 
-  test_checkName() {
-    indexTestUnit('''
+  test_checkName() async {
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // null
     refactoring.name = null;
     assertRefactoringStatus(
         refactoring.checkName(), RefactoringProblemSeverity.FATAL,
         expectedMessage: "Method name must not be null.");
     // empty
     refactoring.name = '';
     assertRefactoringStatus(
         refactoring.checkName(), RefactoringProblemSeverity.FATAL,
         expectedMessage: "Method name must not be empty.");
     // OK
     refactoring.name = 'res';
     assertRefactoringStatusOK(refactoring.checkName());
   }
 
-  test_closure_asFunction_singleExpression() {
-    indexTestUnit('''
+  test_closure_asFunction_singleExpression() async {
+    await indexTestUnit('''
 process(f(x)) {}
 main() {
   process((x) => x * 2);
 }
 ''');
     _createRefactoringForString('(x) => x * 2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 process(f(x)) {}
 main() {
   process(res);
 }
 
 res(x) => x * 2;
 ''');
   }
 
-  test_closure_asFunction_statements() {
-    indexTestUnit('''
+  test_closure_asFunction_statements() async {
+    await indexTestUnit('''
 process(f(x)) {}
 main() {
   process((x) {
     print(x);
     return x * 2;
   }); // marker
 }
 ''');
     _createRefactoringForStartEndString('(x) {', '); // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 process(f(x)) {}
 main() {
   process(res); // marker
 }
 
 res(x) {
   print(x);
   return x * 2;
 }
 ''');
   }
 
-  test_closure_asMethod_statements() {
-    indexTestUnit('''
+  test_closure_asMethod_statements() async {
+    await indexTestUnit('''
 process(f(x)) {}
 class A {
   int k = 2;
   main() {
     process((x) {
       print(x);
       return x * k;
     }); // marker
   }
 }
@@ skipping 10 matching lines @@
 
   res(x) {
     print(x);
     return x * k;
   }
 }
 ''');
   }
 
   test_closure_bad_referencesLocalVariable() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 process(f(x)) {}
 main() {
   int k = 2;
   process((x) => x * k);
 }
 ''');
     _createRefactoringForString('(x) => x * k');
     // check
     RefactoringStatus status = await refactoring.checkInitialConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage:
             'Cannot extract closure as method, it references 1 external variable(s).');
   }
 
   test_closure_bad_referencesParameter() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 process(f(x)) {}
 main(int k) {
   process((x) => x * k);
 }
 ''');
     _createRefactoringForString('(x) => x * k');
     // check
     RefactoringStatus status = await refactoring.checkInitialConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage:
             'Cannot extract closure as method, it references 1 external variable(s).');
   }
 
-  test_fromTopLevelVariableInitializerClosure() {
-    indexTestUnit('''
+  test_fromTopLevelVariableInitializerClosure() async {
+    await indexTestUnit('''
 var X = 1;
 
 var Y = () {
   return 1 + X;
 };
 ''');
     _createRefactoringForString('1 + X');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 var X = 1;
 
 var Y = () {
   return res();
 };
 
 num res() => 1 + X;
 ''');
   }
 
   test_getExtractGetter_expression_true_binaryExpression() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   print(1 + 2);
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, true);
   }
 
   test_getExtractGetter_expression_true_literal() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   print(42);
 }
 ''');
     _createRefactoringForString('42');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, true);
   }
 
   test_getExtractGetter_expression_true_prefixedExpression() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   print(!true);
 }
 ''');
     _createRefactoringForString('!true');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, true);
   }
 
   test_getExtractGetter_expression_true_prefixedIdentifier() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   print(myValue.isEven);
 }
 int get myValue => 42;
 ''');
     _createRefactoringForString('myValue.isEven');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, true);
   }
 
   test_getExtractGetter_expression_true_propertyAccess() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   print(1.isEven);
 }
 ''');
     _createRefactoringForString('1.isEven');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, true);
   }
 
   test_getExtractGetter_statements() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
 // start
   int v = 0;
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.createGetter, false);
   }
 
-  test_getRefactoringName_function() {
-    indexTestUnit('''
+  test_getRefactoringName_function() async {
+    await indexTestUnit('''
 main() {
   print(1 + 2);
 }
 ''');
     _createRefactoringForString('1 + 2');
     expect(refactoring.refactoringName, 'Extract Function');
   }
 
-  test_getRefactoringName_method() {
-    indexTestUnit('''
+  test_getRefactoringName_method() async {
+    await indexTestUnit('''
 class A {
   main() {
     print(1 + 2);
   }
 }
 ''');
     _createRefactoringForString('1 + 2');
     expect(refactoring.refactoringName, 'Extract Method');
   }
 
   test_names_singleExpression() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 class TreeItem {}
 TreeItem getSelectedItem() => null;
 process(my) {}
 main() {
   process(getSelectedItem()); // marker
   int treeItem = 0;
 }
 ''');
     _createRefactoringWithSuffix('getSelectedItem()', '); // marker');
     // check names
     await refactoring.checkInitialConditions();
     expect(refactoring.names,
         unorderedEquals(['selectedItem', 'item', 'my', 'treeItem2']));
   }
 
   test_offsets_lengths() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
   int b = 1 +  2;
 }
 ''');
     _createRefactoringForString('1 +  2');
     // apply refactoring
     await refactoring.checkInitialConditions();
     expect(refactoring.offsets,
         unorderedEquals([findOffset('1 + 2'), findOffset('1 +  2')]));
     expect(refactoring.lengths, unorderedEquals([5, 6]));
   }
 
   test_returnType_closure() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 process(f(x)) {}
 main() {
   process((x) => x * 2);
 }
 ''');
     _createRefactoringForString('(x) => x * 2');
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, '');
   }
 
   test_returnType_expression() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, 'int');
   }
 
   test_returnType_mixInterfaceFunction() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
 // start
   if (true) {
     return 1;
   } else {
     return () {};
   }
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, 'Object');
   }
 
   test_returnType_statements() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
 // start
   double v = 5.0;
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, 'double');
   }
 
   test_returnType_statements_nullMix() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main(bool p) {
 // start
   if (p) {
     return 42;
   }
   return null;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, 'int');
   }
 
   test_returnType_statements_void() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
 // start
   print(42);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // do check
     await refactoring.checkInitialConditions();
     expect(refactoring.returnType, 'void');
   }
 
   test_setExtractGetter() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     await assertRefactoringConditionsOK();
     expect(refactoring.canCreateGetter, true);
     expect(refactoring.createGetter, true);
     refactoringChange = await refactoring.createChange();
     assertTestChangeResult('''
 main() {
   int a = res;
 }
 
 int get res => 1 + 2;
 ''');
   }
 
-  test_singleExpression() {
-    indexTestUnit('''
+  test_singleExpression() async {
+    await indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int a = res();
 }
 
 int res() => 1 + 2;
 ''');
   }
 
-  test_singleExpression_cascade() {
-    indexTestUnit('''
+  test_singleExpression_cascade() async {
+    await indexTestUnit('''
 main() {
   String s = '';
   var v = s..length;
 }
 ''');
     _createRefactoringForString('s..length');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   String s = '';
   var v = res(s);
 }
 
 String res(String s) => s..length;
 ''');
   }
 
-  test_singleExpression_dynamic() {
-    indexTestUnit('''
+  test_singleExpression_dynamic() async {
+    await indexTestUnit('''
 dynaFunction() {}
 main() {
   var v = dynaFunction(); // marker
 }
 ''');
     _createRefactoringWithSuffix('dynaFunction()', '; // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 dynaFunction() {}
 main() {
   var v = res(); // marker
 }
 
 res() => dynaFunction();
 ''');
   }
 
-  test_singleExpression_hasAwait() {
-    indexTestUnit('''
+  test_singleExpression_hasAwait() async {
+    await indexTestUnit('''
 import 'dart:async';
 Future<int> getValue() => 42;
 main() async {
   int v = await getValue();
   print(v);
 }
 ''');
     _createRefactoringForString('await getValue()');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'dart:async';
 Future<int> getValue() => 42;
 main() async {
   int v = await res();
   print(v);
 }
 
 Future<int> res() async => await getValue();
 ''');
   }
 
-  test_singleExpression_ignore_assignmentLeftHandSize() {
-    indexTestUnit('''
+  test_singleExpression_ignore_assignmentLeftHandSize() async {
+    await indexTestUnit('''
 main() {
   getButton().text = 'txt';
   print(getButton().text); // marker
 }
 getButton() {}
 ''');
     _createRefactoringWithSuffix('getButton().text', '); // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   getButton().text = 'txt';
   print(res()); // marker
 }
 
 res() => getButton().text;
 getButton() {}
 ''');
   }
 
-  test_singleExpression_occurrences() {
-    indexTestUnit('''
+  test_singleExpression_occurrences() async {
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int positiveA = v1 + v2; // marker
   int positiveB = v2 + v3;
   int positiveC = v1 +  v2;
   int positiveD = v1/*abc*/ + v2;
   int negA = 1 + 2;
   int negB = 1 + v2;
@@ skipping 15 matching lines @@
   int negA = 1 + 2;
   int negB = 1 + v2;
   int negC = v1 + 2;
   int negD = v1 * v2;
 }
 
 int res(int v1, int v2) => v1 + v2;
 ''');
   }
 
-  test_singleExpression_occurrences_disabled() {
-    indexTestUnit('''
+  test_singleExpression_occurrences_disabled() async {
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = v1 + v2; // marker
   int b = v2 + v3;
 }
 ''');
     _createRefactoringWithSuffix('v1 + v2', '; // marker');
     refactoring.extractAll = false;
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = res(v1, v2); // marker
   int b = v2 + v3;
 }
 
 int res(int v1, int v2) => v1 + v2;
 ''');
   }
 
-  test_singleExpression_occurrences_inClassOnly() {
-    indexTestUnit('''
+  test_singleExpression_occurrences_inClassOnly() async {
+    await indexTestUnit('''
 class A {
   myMethod() {
     int v1 = 1;
     int v2 = 2;
     int positiveA = v1 + v2; // marker
   }
 }
 main() {
   int v1 = 1;
   int v2 = 2;
@@ skipping 13 matching lines @@
   int res(int v1, int v2) => v1 + v2;
 }
 main() {
   int v1 = 1;
   int v2 = 2;
   int negA = v1 + v2;
 }
 ''');
   }
 
-  test_singleExpression_occurrences_incompatibleTypes() {
-    indexTestUnit('''
+  test_singleExpression_occurrences_incompatibleTypes() async {
+    await indexTestUnit('''
 main() {
   int x = 1;
   String y = 'foo';
   print(x.toString());
   print(y.toString());
 }
 ''');
     _createRefactoringForString('x.toString()');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int x = 1;
   String y = 'foo';
   print(res(x));
   print(y.toString());
 }
 
 String res(int x) => x.toString();
 ''');
   }
 
-  test_singleExpression_occurrences_inWholeUnit() {
-    indexTestUnit('''
+  test_singleExpression_occurrences_inWholeUnit() async {
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int positiveA = v1 + v2; // marker
 }
 class A {
   myMethod() {
     int v1 = 1;
     int v2 = 2;
     int positiveB = v1 + v2;
@@ skipping 13 matching lines @@
 class A {
   myMethod() {
     int v1 = 1;
     int v2 = 2;
     int positiveB = res(v1, v2);
   }
 }
 ''');
   }
 
-  test_singleExpression_parameter_functionTypeAlias() {
-    indexTestUnit('''
+  test_singleExpression_parameter_functionTypeAlias() async {
+    await indexTestUnit('''
 typedef R Foo<S, R>(S s);
 void main(Foo<String, int> foo, String s) {
   int a = foo(s);
 }
 ''');
     _createRefactoringForString('foo(s)');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 typedef R Foo<S, R>(S s);
 void main(Foo<String, int> foo, String s) {
   int a = res(foo, s);
 }
 
 int res(Foo<String, int> foo, String s) => foo(s);
 ''');
   }
 
   test_singleExpression_returnType_importLibrary() async {
     _addLibraryReturningAsync();
-    indexTestUnit('''
+    await indexTestUnit('''
 import 'asyncLib.dart';
 main() {
   var a = newFuture();
 }
 ''');
     _createRefactoringForString('newFuture()');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'asyncLib.dart';
 import 'dart:async';
 main() {
   var a = res();
 }
 
 Future<int> res() => newFuture();
 ''');
   }
 
-  test_singleExpression_returnTypeGeneric() {
-    indexTestUnit('''
+  test_singleExpression_returnTypeGeneric() async {
+    await indexTestUnit('''
 main() {
   var v = new List<String>();
 }
 ''');
     _createRefactoringForString('new List<String>()');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var v = res();
 }
 
 List<String> res() => new List<String>();
 ''');
   }
 
-  test_singleExpression_returnTypePrefix() {
-    indexTestUnit('''
+  test_singleExpression_returnTypePrefix() async {
+    await indexTestUnit('''
 import 'dart:math' as pref;
 main() {
   var v = new pref.Random();
 }
 ''');
     _createRefactoringForString('new pref.Random()');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'dart:math' as pref;
 main() {
   var v = res();
 }
 
 pref.Random res() => new pref.Random();
 ''');
   }
 
-  test_singleExpression_staticContext_extractFromInitializer() {
-    indexTestUnit('''
+  test_singleExpression_staticContext_extractFromInitializer() async {
+    await indexTestUnit('''
 class A {
   A(int v) {}
 }
 class B extends A {
   B() : super(1 + 2) {}
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 class A {
   A(int v) {}
 }
 class B extends A {
   B() : super(res()) {}
 
   static int res() => 1 + 2;
 }
 ''');
   }
 
-  test_singleExpression_staticContext_extractFromInstance() {
-    indexTestUnit('''
+  test_singleExpression_staticContext_extractFromInstance() async {
+    await indexTestUnit('''
 class A {
   instanceMethodA() {
     int v1 = 1;
     int v2 = 2;
     int positiveA = v1 + v2; // marker
   }
   instanceMethodB() {
     int v1 = 1;
     int v2 = 2;
     int positiveB = v1 + v2;
@@ skipping 23 matching lines @@
   }
   static staticMethodA() {
     int v1 = 1;
     int v2 = 2;
     int positiveA = res(v1, v2);
   }
 }
 ''');
   }
 
-  test_singleExpression_staticContext_extractFromStatic() {
-    indexTestUnit('''
+  test_singleExpression_staticContext_extractFromStatic() async {
+    await indexTestUnit('''
 class A {
   static staticMethodA() {
     int v1 = 1;
     int v2 = 2;
     int positiveA = v1 + v2; // marker
   }
   static staticMethodB() {
     int v1 = 1;
     int v2 = 2;
     int positiveB = v1 + v2;
@@ skipping 23 matching lines @@
   }
   instanceMethodA() {
     int v1 = 1;
     int v2 = 2;
     int positiveA = res(v1, v2);
   }
 }
 ''');
   }
 
-  test_singleExpression_staticContext_hasInInitializer() {
-    indexTestUnit('''
+  test_singleExpression_staticContext_hasInInitializer() async {
+    await indexTestUnit('''
 class A {
   A(int v) {}
 }
 class B extends A {
   B() : super(1 + 2) {}
   foo() {
     print(1 + 2); // marker
   }
 }
 ''');
     _createRefactoringWithSuffix('1 + 2', '); // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 class A {
   A(int v) {}
 }
 class B extends A {
   B() : super(res()) {}
   foo() {
     print(res()); // marker
   }
 
   static int res() => 1 + 2;
 }
 ''');
   }
 
-  test_singleExpression_usesParameter() {
-    indexTestUnit('''
+  test_singleExpression_usesParameter() async {
+    await indexTestUnit('''
 fooA(int a1) {
   int a2 = 2;
   int a = a1 + a2;
 }
 fooB(int b1) {
   int b2 = 2;
   int b = b1 + b2;
 }
 ''');
     _createRefactoringForString('a1 + a2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 fooA(int a1) {
   int a2 = 2;
   int a = res(a1, a2);
 }
 
 int res(int a1, int a2) => a1 + a2;
 fooB(int b1) {
   int b2 = 2;
   int b = res(b1, b2);
 }
 ''');
   }
 
-  test_singleExpression_withVariables() {
-    indexTestUnit('''
+  test_singleExpression_withVariables() async {
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = v1 + v2 + v1;
 }
 ''');
     _createRefactoringForString('v1 + v2 + v1');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = res(v1, v2);
 }
 
 int res(int v1, int v2) => v1 + v2 + v1;
 ''');
   }
 
   test_singleExpression_withVariables_doRename() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = v1 + v2 + v1; // marker
   int b = v2 + v3 + v2;
 }
 ''');
     _createRefactoringForString('v1 + v2 + v1');
     // apply refactoring
@@ skipping 16 matching lines @@
   int v3 = 3;
   int a = res(v1, v2); // marker
   int b = res(v2, v3);
 }
 
 int res(int par1, int param2) => par1 + param2 + par1;
 ''');
   }
 
   test_singleExpression_withVariables_doReorder() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = v1 + v2; // marker
   int b = v2 + v3;
 }
 ''');
     _createRefactoringForString('v1 + v2');
     // apply refactoring
@@ skipping 15 matching lines @@
   int v2 = 2;
   int v3 = 3;
   int a = res(v2, v1); // marker
   int b = res(v3, v2);
 }
 
 int res(int v2, int v1) => v1 + v2;
 ''');
   }
 
-  test_singleExpression_withVariables_namedExpression() {
-    indexTestUnit('''
+  test_singleExpression_withVariables_namedExpression() async {
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = process(arg: v1 + v2);
 }
 process({arg}) {}
 ''');
     _createRefactoringForString('process(arg: v1 + v2)');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = res(v1, v2);
 }
 
 res(int v1, int v2) => process(arg: v1 + v2);
 process({arg}) {}
 ''');
   }
 
   test_singleExpression_withVariables_newType() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = v1 + v2 + v3;
 }
 ''');
     _createRefactoringForString('v1 + v2 + v3');
     // apply refactoring
     await refactoring.checkInitialConditions();
@@ skipping 15 matching lines @@
   int v1 = 1;
   int v2 = 2;
   int v3 = 3;
   int a = res(v1, v2, v3);
 }
 
 int res(num v1, v2, v3) => v1 + v2 + v3;
 ''');
   }
 
-  test_singleExpression_withVariables_useBestType() {
-    indexTestUnit('''
+  test_singleExpression_withVariables_useBestType() async {
+    await indexTestUnit('''
 main() {
   var v1 = 1;
   var v2 = 2;
   var a = v1 + v2 + v1; // marker
 }
 ''');
     _createRefactoringForString('v1 + v2 + v1');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var v1 = 1;
   var v2 = 2;
   var a = res(v1, v2); // marker
 }
 
 int res(int v1, int v2) => v1 + v2 + v1;
 ''');
   }
 
-  test_statements_assignment() {
-    indexTestUnit('''
+  test_statements_assignment() async {
+    await indexTestUnit('''
 main() {
   int v;
 // start
   v = 5;
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v;
 // start
   v = res(v);
 // end
   print(v);
 }
 
 int res(int v) {
   v = 5;
   return v;
 }
 ''');
   }
 
-  test_statements_changeIndentation() {
-    indexTestUnit('''
+  test_statements_changeIndentation() async {
+    await indexTestUnit('''
 main() {
   {
 // start
     if (true) {
       print(0);
     }
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   {
 // start
     res();
 // end
   }
 }
 
 void res() {
   if (true) {
     print(0);
   }
 }
 ''');
   }
 
-  test_statements_changeIndentation_multilineString() {
-    indexTestUnit('''
+  test_statements_changeIndentation_multilineString() async {
+    await indexTestUnit('''
 main() {
   {
 // start
     print("""
 first line
 second line
     """);
 // end
   }
 }
@@ skipping 11 matching lines @@
 
 void res() {
   print("""
 first line
 second line
     """);
 }
 ''');
   }
 
-  test_statements_definesVariable_notUsedOutside() {
-    indexTestUnit('''
+  test_statements_definesVariable_notUsedOutside() async {
+    await indexTestUnit('''
 main() {
   int a = 1;
   int b = 1;
 // start
   int v = a + b;
   print(v);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int a = 1;
   int b = 1;
 // start
   res(a, b);
 // end
 }
 
 void res(int a, int b) {
   int v = a + b;
   print(v);
 }
 ''');
   }
 
-  test_statements_definesVariable_oneUsedOutside_assignment() {
-    indexTestUnit('''
+  test_statements_definesVariable_oneUsedOutside_assignment() async {
+    await indexTestUnit('''
 myFunctionA() {
   int a = 1;
 // start
   a += 10;
 // end
   print(a);
 }
 myFunctionB() {
   int b = 2;
   b += 10;
@@ skipping 16 matching lines @@
   return a;
 }
 myFunctionB() {
   int b = 2;
   b = res(b);
   print(b);
 }
 ''');
   }
 
-  test_statements_definesVariable_oneUsedOutside_declaration() {
-    indexTestUnit('''
+  test_statements_definesVariable_oneUsedOutside_declaration() async {
+    await indexTestUnit('''
 myFunctionA() {
   int a = 1;
   int b = 2;
 // start
   int v1 = a + b;
 // end
   print(v1);
 }
 myFunctionB() {
   int a = 3;
@@ skipping 21 matching lines @@
 myFunctionB() {
   int a = 3;
   int b = 4;
   int v2 = res(a, b);
   print(v2);
 }
 ''');
   }
 
   test_statements_definesVariable_twoUsedOutside() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main() {
 // start
   int varA = 1;
   int varB = 2;
 // end
   int v = varA + varB;
 }
 ''');
     _createRefactoringForStartEndComments();
     // check conditions
     RefactoringStatus status = await refactoring.checkInitialConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL);
   }
 
-  test_statements_duplicate_absolutelySame() {
-    indexTestUnit('''
+  test_statements_duplicate_absolutelySame() async {
+    await indexTestUnit('''
 myFunctionA() {
   print(0);
   print(1);
 }
 myFunctionB() {
 // start
   print(0);
   print(1);
 // end
 }
@@ skipping 10 matching lines @@
 // end
 }
 
 void res() {
   print(0);
   print(1);
 }
 ''');
   }
 
-  test_statements_duplicate_declaresDifferentlyNamedVariable() {
-    indexTestUnit('''
+  test_statements_duplicate_declaresDifferentlyNamedVariable() async {
+    await indexTestUnit('''
 myFunctionA() {
   int varA = 1;
   print(varA);
 }
 myFunctionB() {
 // start
   int varB = 1;
   print(varB);
 // end
 }
@@ skipping 10 matching lines @@
 // end
 }
 
 void res() {
   int varB = 1;
   print(varB);
 }
 ''');
   }
 
-  test_statements_dynamic() {
-    indexTestUnit('''
+  test_statements_dynamic() async {
+    await indexTestUnit('''
 dynaFunction(p) => 0;
 main() {
 // start
   var a = 1;
   var v = dynaFunction(a);
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
@@ skipping 11 matching lines @@
   var a = 1;
   var v = dynaFunction(a);
   return v;
 }
 ''');
   }
 
   /**
    * We should always add ";" when invoke method with extracted statements.
    */
-  test_statements_endsWithBlock() {
-    indexTestUnit('''
+  test_statements_endsWithBlock() async {
+    await indexTestUnit('''
 main() {
 // start
   if (true) {
     print(0);
   }
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
 // start
   res();
 // end
 }
 
 void res() {
   if (true) {
     print(0);
   }
 }
 ''');
   }
 
   test_statements_exit_throws() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main(int p) {
 // start
   if (p == 0) {
     return;
   }
   throw 'boo!';
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     await assertRefactoringConditionsOK();
   }
 
-  test_statements_hasAwait_dynamicReturnType() {
-    indexTestUnit('''
+  test_statements_hasAwait_dynamicReturnType() async {
+    await indexTestUnit('''
 import 'dart:async';
 Future getValue() => 42;
 main() async {
 // start
   var v = await getValue();
 // end
   print(v);
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'dart:async';
 Future getValue() => 42;
 main() async {
 // start
   var v = await res();
 // end
   print(v);
 }
 
 Future res() async {
   var v = await getValue();
   return v;
 }
 ''');
   }
 
-  test_statements_hasAwait_expression() {
-    indexTestUnit('''
+  test_statements_hasAwait_expression() async {
+    await indexTestUnit('''
 import 'dart:async';
 Future<int> getValue() => 42;
 main() async {
 // start
   int v = await getValue();
   v += 2;
 // end
   print(v);
 }
 ''');
@@ skipping 10 matching lines @@
 }
 
 Future<int> res() async {
   int v = await getValue();
   v += 2;
   return v;
 }
 ''');
   }
 
-  test_statements_hasAwait_forEach() {
-    indexTestUnit('''
+  test_statements_hasAwait_forEach() async {
+    await indexTestUnit('''
 import 'dart:async';
 Stream<int> getValueStream() => null;
 main() async {
 // start
   int sum = 0;
   await for (int v in getValueStream()) {
     sum += v;
   }
 // end
   print(sum);
@@ skipping 14 matching lines @@
 Future<int> res() async {
   int sum = 0;
   await for (int v in getValueStream()) {
     sum += v;
   }
   return sum;
 }
 ''');
   }
 
-  test_statements_hasAwait_voidReturnType() {
-    indexTestUnit('''
+  test_statements_hasAwait_voidReturnType() async {
+    await indexTestUnit('''
 import 'dart:async';
 Future<int> getValue() => 42;
 main() async {
 // start
   int v = await getValue();
   print(v);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'dart:async';
 Future<int> getValue() => 42;
 main() async {
 // start
   await res();
 // end
 }
 
 Future res() async {
   int v = await getValue();
   print(v);
 }
 ''');
   }
 
-  test_statements_inSwitchMember() {
-    indexTestUnit('''
+  test_statements_inSwitchMember() async {
+    await indexTestUnit('''
 class A {
   foo(int p) {
     switch (p) {
       case 0:
 // start
         print(0);
 // end
         break;
       default:
         break;
@@ skipping 17 matching lines @@
     }
   }
 
   void res() {
     print(0);
   }
 }
 ''');
   }
 
-  test_statements_method() {
-    indexTestUnit('''
+  test_statements_method() async {
+    await indexTestUnit('''
 class A {
   foo() {
 // start
     print(0);
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 class A {
   foo() {
 // start
     res();
 // end
   }
 
   void res() {
     print(0);
   }
 }
 ''');
   }
 
-  test_statements_noDuplicates() {
-    indexTestUnit('''
+  test_statements_noDuplicates() async {
+    await indexTestUnit('''
 main() {
   int a = 1;
   int b = 1;
 // start
   print(a);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int a = 1;
   int b = 1;
 // start
   res(a);
 // end
 }
 
 void res(int a) {
   print(a);
 }
 ''');
   }
 
   test_statements_parameters_ignoreInnerPropagatedType() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 main(Object x) {
 // start
   if (x is int) {
     print('int');
   }
   if (x is bool) {
     print('bool');
   }
 // end
 }
@@ skipping 11 matching lines @@
   if (x is int) {
     print('int');
   }
   if (x is bool) {
     print('bool');
   }
 }
 ''');
   }
 
-  test_statements_parameters_importType() {
+  test_statements_parameters_importType() async {
     _addLibraryReturningAsync();
-    indexTestUnit('''
+    await indexTestUnit('''
 import 'asyncLib.dart';
 main() {
   var v = newFuture();
 // start
   print(v);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 import 'asyncLib.dart';
 import 'dart:async';
 main() {
   var v = newFuture();
 // start
   res(v);
 // end
 }
 
 void res(Future<int> v) {
   print(v);
 }
 ''');
   }
 
-  test_statements_parameters_localFunction() {
+  test_statements_parameters_localFunction() async {
     _addLibraryReturningAsync();
-    indexTestUnit('''
+    await indexTestUnit('''
 class C {
   int f(int a) {
     int callback(int x, int y) => x + a;
     int b = a + 1;
 // start
     int c = callback(b, 2);
 // end
     int d = c + 1;
     return d;
   }
@@ skipping 13 matching lines @@
   }
 
   int res(int callback(int x, int y), int b) {
     int c = callback(b, 2);
     return c;
   }
 }''');
   }
 
   test_statements_parameters_noLocalVariableConflict() async {
-    indexTestUnit('''
+    await indexTestUnit('''
 int f(int x) {
   int y = x + 1;
 // start
   if (y % 2 == 0) {
     int y = x + 2;
     return y;
   } else {
     return y;
   }
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     await assertRefactoringConditionsOK();
   }
 
-  test_statements_return_last() {
-    indexTestUnit('''
+  test_statements_return_last() async {
+    await indexTestUnit('''
 main() {
 // start
   int v = 5;
   return v + 1;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
 // start
   return res();
 // end
 }
 
 int res() {
   int v = 5;
   return v + 1;
 }
 ''');
   }
 
-  test_statements_return_multiple_ifElse() {
-    indexTestUnit('''
+  test_statements_return_multiple_ifElse() async {
+    await indexTestUnit('''
 num main(bool b) {
 // start
   if (b) {
     return 1;
   } else {
     return 2.0;
   }
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 num main(bool b) {
 // start
   return res(b);
 // end
 }
 
 num res(bool b) {
   if (b) {
     return 1;
   } else {
     return 2.0;
   }
 }
 ''');
   }
 
-  test_statements_return_multiple_ifThen() {
-    indexTestUnit('''
+  test_statements_return_multiple_ifThen() async {
+    await indexTestUnit('''
 num main(bool b) {
 // start
   if (b) {
     return 1;
   }
   return 2.0;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 num main(bool b) {
 // start
   return res(b);
 // end
 }
 
 num res(bool b) {
   if (b) {
     return 1;
   }
   return 2.0;
 }
 ''');
   }
 
-  test_statements_return_multiple_ignoreInFunction() {
-    indexTestUnit('''
+  test_statements_return_multiple_ignoreInFunction() async {
+    await indexTestUnit('''
 int main() {
 // start
   localFunction() {
     return 'abc';
   }
   return 42;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 int main() {
 // start
   return res();
 // end
 }
 
 int res() {
   localFunction() {
     return 'abc';
   }
   return 42;
 }
 ''');
   }
 
-  test_statements_return_multiple_interfaceFunction() {
-    indexTestUnit('''
+  test_statements_return_multiple_interfaceFunction() async {
+    await indexTestUnit('''
 main(bool b) {
 // start
   if (b) {
     return 1;
   }
   return () {};
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main(bool b) {
 // start
   return res(b);
 // end
 }
 
 Object res(bool b) {
   if (b) {
     return 1;
   }
   return () {};
 }
 ''');
   }
 
-  test_statements_return_multiple_sameElementDifferentTypeArgs() {
-    indexTestUnit('''
+  test_statements_return_multiple_sameElementDifferentTypeArgs() async {
+    await indexTestUnit('''
 main(bool b) {
 // start
   if (b) {
     print(true);
     return <int>[];
   } else {
     print(false);
     return <String>[];
   }
 // end
@@ skipping 13 matching lines @@
     print(true);
     return <int>[];
   } else {
     print(false);
     return <String>[];
   }
 }
 ''');
   }
 
-  test_statements_return_single() {
-    indexTestUnit('''
+  test_statements_return_single() async {
+    await indexTestUnit('''
 main() {
 // start
   return 42;
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
 // start
   return res();
 // end
 }
 
 int res() {
   return 42;
 }
 ''');
   }
 
   /**
    * We have 3 identical statements, but select only 2.
    * This should not cause problems.
    */
-  test_statements_twoOfThree() {
-    indexTestUnit('''
+  test_statements_twoOfThree() async {
+    await indexTestUnit('''
 main() {
 // start
   print(0);
   print(0);
 // end
   print(0);
 }
 ''');
     _createRefactoringForStartEndComments();
     // apply refactoring
@@ skipping 95 matching lines @@
    * Returns a deep copy of [refactoring] parameters.
    * There was a bug masked by updating parameter instances shared between the
    * refactoring and the test.
    */
   List<RefactoringMethodParameter> _getParametersCopy() {
     return refactoring.parameters.map((p) {
       return new RefactoringMethodParameter(p.kind, p.type, p.name, id: p.id);
     }).toList();
   }
 }