Convert refactoring tests to use 'await'.

pkg/analysis_server/test/services/refactoring/extract_local_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_local;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
+import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/refactoring/extract_local.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../reflective_tests.dart';
 import 'abstract_refactoring.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ExtractLocalTest);
 }
 
 
 @reflectiveTest
 class ExtractLocalTest extends RefactoringTest {
   ExtractLocalRefactoringImpl refactoring;
 
-  test_checkFinalConditions_sameVariable_after() {
+  test_checkFinalConditions_sameVariable_after() async {
     indexTestUnit('''
 main() {
   int a = 1 + 2;
   var res;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // conflicting name
-    return refactoring.checkAllConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.WARNING,
-          expectedMessage:
-              "A variable with name 'res' is already defined in the visible scope.");
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.WARNING,
+        expectedMessage:
+            "A variable with name 'res' is already defined in the visible scope.");
   }
 
-  test_checkFinalConditions_sameVariable_before() {
+  test_checkFinalConditions_sameVariable_before() async {
     indexTestUnit('''
 main() {
   var res;
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // conflicting name
-    return refactoring.checkAllConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.WARNING,
-          expectedMessage:
-              "A variable with name 'res' is already defined in the visible scope.");
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.WARNING,
+        expectedMessage:
+            "A variable with name 'res' is already defined in the visible scope.");
   }
 
-  test_checkInitialConditions_assignmentLeftHandSize() {
+  test_checkInitialConditions_assignmentLeftHandSize() async {
     indexTestUnit('''
 main() {
   var v = 0;
   v = 1;
 }
 ''');
     _createRefactoringWithSuffix('v', ' = 1;');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Cannot extract the left-hand side of an assignment.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Cannot extract the left-hand side of an assignment.');
   }
 
-  test_checkInitialConditions_methodName_reference() {
+  test_checkInitialConditions_methodName_reference() async {
     indexTestUnit('''
 main() {
   main();
 }
 ''');
     _createRefactoringWithSuffix('main', '();');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Cannot extract a single method name.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Cannot extract a single method name.');
   }
 
-  test_checkInitialConditions_nameOfProperty_prefixedIdentifier() {
+  test_checkInitialConditions_nameOfProperty_prefixedIdentifier() async {
     indexTestUnit('''
 main(p) {
   p.value; // marker
 }
 ''');
     _createRefactoringWithSuffix('value', '; // marker');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Cannot extract name part of a property access.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Cannot extract name part of a property access.');
   }
 
-  test_checkInitialConditions_nameOfProperty_propertyAccess() {
+  test_checkInitialConditions_nameOfProperty_propertyAccess() async {
     indexTestUnit('''
 main() {
   foo().length; // marker
 }
 String foo() => '';
 ''');
     _createRefactoringWithSuffix('length', '; // marker');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Cannot extract name part of a property access.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Cannot extract name part of a property access.');
   }
 
-  test_checkInitialConditions_namePartOfDeclaration_variable() {
+  test_checkInitialConditions_namePartOfDeclaration_variable() async {
     indexTestUnit('''
 main() {
   int vvv = 0;
 }
 ''');
     _createRefactoringWithSuffix('vvv', ' = 0;');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Cannot extract the name part of a declaration.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Cannot extract the name part of a declaration.');
   }
 
-  test_checkInitialConditions_notPartOfFunction() {
+  test_checkInitialConditions_notPartOfFunction() async {
     indexTestUnit('''
 int a = 1 + 2;
 ''');
     _createRefactoringForString('1 + 2');
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage:
-              'Expression inside of function must be selected to activate this refactoring.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage:
+            'Expression inside of function must be selected to activate this refactoring.');
   }
 
-  test_checkInitialConditions_stringSelection_leadingQuote() {
+  test_checkInitialConditions_stringSelection_leadingQuote() async {
     indexTestUnit('''
 main() {
   var vvv = 'abc';
 }
 ''');
     _createRefactoringForString("'a");
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage:
-              'Cannot extract only leading or trailing quote of string literal.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage:
+            'Cannot extract only leading or trailing quote of string literal.');
   }
 
-  test_checkInitialConditions_stringSelection_trailingQuote() {
+  test_checkInitialConditions_stringSelection_trailingQuote() async {
     indexTestUnit('''
 main() {
   var vvv = 'abc';
 }
 ''');
     _createRefactoringForString("c'");
     // check conditions
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage:
-              'Cannot extract only leading or trailing quote of string literal.');
-    });
+    RefactoringStatus status = await refactoring.checkAllConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage:
+            'Cannot extract only leading or trailing quote of string literal.');
   }
 
   test_checkLocalName() {
     indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     expect(refactoring.refactoringName, 'Extract Local Variable');
@@ skipping 259 matching lines @@
     _createRefactoringForString('2 + 3 ');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var res = 2 + 3 ;
   int a = 1 + res+ 4;
 }
 ''');
   }
 
-  test_guessNames_fragmentExpression() {
+  test_guessNames_fragmentExpression() async {
     indexTestUnit('''
 main() {
   var a = 111 + 222 + 333 + 444;
 }
 ''');
     _createRefactoringForString('222 + 333');
     // check guesses
-    return refactoring.checkInitialConditions().then((_) {
-      expect(refactoring.names, isEmpty);
-    });
+    await refactoring.checkInitialConditions();
+    expect(refactoring.names, isEmpty);
   }
 
-  test_guessNames_singleExpression() {
+  test_guessNames_singleExpression() async {
     indexTestUnit('''
 class TreeItem {}
 TreeItem getSelectedItem() => null;
 process(my) {}
 main() {
   process(getSelectedItem()); // marker
 }
 ''');
     _createRefactoringWithSuffix('getSelectedItem()', '); // marker');
     // check guesses
-    return refactoring.checkInitialConditions().then((_) {
-      expect(
-          refactoring.names,
-          unorderedEquals(['selectedItem', 'item', 'my', 'treeItem']));
-    });
+    await refactoring.checkInitialConditions();
+    expect(
+        refactoring.names,
+        unorderedEquals(['selectedItem', 'item', 'my', 'treeItem']));
   }
 
-  test_guessNames_stringPart() {
+  test_guessNames_stringPart() async {
     indexTestUnit('''
 main() {
   var s = 'Hello Bob... welcome to Dart!';
 }
 ''');
     _createRefactoringForString('Hello Bob');
     // check guesses
-    return refactoring.checkInitialConditions().then((_) {
-      expect(refactoring.names, unorderedEquals(['helloBob', 'bob']));
-    });
+    await refactoring.checkInitialConditions();
+    expect(refactoring.names, unorderedEquals(['helloBob', 'bob']));
   }
 
   test_occurences_differentVariable() {
     indexTestUnit('''
 main() {
   {
     int v = 1;
     print(v + 1); // marker
     print(v + 1);
   }
@@ skipping 161 matching lines @@
     return _assertSuccessfulRefactoring('''
 int foo(String s) => 42;
 main() {
   var res = foo('has space');
   int a = 1 + res;
   int b = 2 + res; // marker
 }
 ''');
   }
 
-  test_offsets_lengths() {
+  test_offsets_lengths() async {
     indexTestUnit('''
 int foo() => 42;
 main() {
   int a = 1 + foo(); // marker
   int b = 2 + foo( );
 }
 ''');
     _createRefactoringWithSuffix('foo()', '; // marker');
-    // apply refactoring
-    return refactoring.checkInitialConditions().then((_) {
-      expect(
-          refactoring.offsets,
-          unorderedEquals([findOffset('foo();'), findOffset('foo( );')]));
-      expect(refactoring.lengths, unorderedEquals([5, 6]));
-    });
+    // check offsets
+    await refactoring.checkInitialConditions();
+    expect(
+        refactoring.offsets,
+        unorderedEquals([findOffset('foo();'), findOffset('foo( );')]));
+    expect(refactoring.lengths, unorderedEquals([5, 6]));
   }
 
   test_singleExpression() {
     indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
@@ skipping 227 matching lines @@
     return _assertSuccessfulRefactoring(r'''
 main() {
   int x = 1;
   int y = 2;
   var res = '$x+$y';
   print('${res}=${x+y}');
 }
 ''');
   }
 
-  Future _assertInitialConditions_fatal_selection() {
-    return refactoring.checkInitialConditions().then((status) {
-      assertRefactoringStatus(
-          status,
-          RefactoringProblemSeverity.FATAL,
-          expectedMessage: 'Expression must be selected to activate this refactoring.');
-    });
+  Future _assertInitialConditions_fatal_selection() async {
+    RefactoringStatus status = await refactoring.checkInitialConditions();
+    assertRefactoringStatus(
+        status,
+        RefactoringProblemSeverity.FATAL,
+        expectedMessage: 'Expression must be selected to activate this refactoring.');
   }
 
   /**
    * Checks that all conditions are OK and the result of applying the [Change]
    * to [testUnit] is [expectedCode].
    */
-  Future _assertSuccessfulRefactoring(String expectedCode) {
-    return assertRefactoringConditionsOK().then((_) {
-      return refactoring.createChange().then((SourceChange refactoringChange) {
-        this.refactoringChange = refactoringChange;
-        assertTestChangeResult(expectedCode);
-      });
-    });
+  Future _assertSuccessfulRefactoring(String expectedCode) async {
+    await assertRefactoringConditionsOK();
+    SourceChange refactoringChange = await refactoring.createChange();
+    this.refactoringChange = refactoringChange;
+    assertTestChangeResult(expectedCode);
   }
 
   void _createRefactoring(int offset, int length) {
     refactoring = new ExtractLocalRefactoring(testUnit, offset, length);
     refactoring.name = 'res';
   }
 
   /**
    * Creates a new refactoring in [refactoring] for the selection range of the
    * given [search] pattern.
    */
   void _createRefactoringForString(String search) {
     int offset = findOffset(search);
     int length = search.length;
     _createRefactoring(offset, length);
   }
 
   void _createRefactoringWithSuffix(String selectionSearch, String suffix) {
     int offset = findOffset(selectionSearch + suffix);
     int length = selectionSearch.length;
     _createRefactoring(offset, length);
   }
 }