Use async/await in all analysis domain tests.

pkg/analysis_server/test/analysis/notification_navigation_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.analysis.notification.navigation;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 161 matching lines @@
     }
     if (exists == true) {
       fail('Expected to find (offset=$offset; length=$length) in\n'
           '${regions.join('\n')}');
     }
   }
 }
 
 @reflectiveTest
 class AnalysisNotificationNavigationTest extends AbstractNavigationTest {
-  Future prepareNavigation() {
+  Future prepareNavigation() async {
     addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
-    return waitForTasksFinished().then((_) {
-      assertRegionsSorted();
-    });
+    await waitForTasksFinished();
+    assertRegionsSorted();
   }
 
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_NAVIGATION) {
       var params = new AnalysisNavigationParams.fromNotification(notification);
       if (params.file == testFile) {
         regions = params.regions;
         targets = params.targets;
         targetFiles = params.files;
       }
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     createProject();
   }
 
-  test_afterAnalysis() {
+  test_afterAnalysis() async {
     addTestFile('''
 class AAA {}
 AAA aaa;
 ''');
-    return waitForTasksFinished().then((_) {
-      return prepareNavigation().then((_) {
-        assertHasRegionTarget('AAA aaa;', 'AAA {}');
-      });
-    });
+    await waitForTasksFinished();
+    await prepareNavigation();
+    assertHasRegionTarget('AAA aaa;', 'AAA {}');
   }
 
   test_annotationConstructor_implicit() async {
     addTestFile('''
 class A {
 }
 @A()
 main() {
 }
 ''');
@@ skipping 89 matching lines @@
     addTestFile('''
 import 'mayn.dart' as man;
 @man.myan // ref
 main() {
 }
 ''');
     await prepareNavigation();
     assertHasRegion('myan // ref');
   }
 
-  test_class_fromSDK() {
+  test_class_fromSDK() async {
     addTestFile('''
 int V = 42;
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegion('int V');
-      int targetIndex = testTargetIndexes[0];
-      NavigationTarget target = targets[targetIndex];
-      expect(target.startLine, greaterThan(0));
-      expect(target.startColumn, greaterThan(0));
-    });
+    await prepareNavigation();
+    assertHasRegion('int V');
+    int targetIndex = testTargetIndexes[0];
+    NavigationTarget target = targets[targetIndex];
+    expect(target.startLine, greaterThan(0));
+    expect(target.startColumn, greaterThan(0));
   }
 
-  test_constructor_named() {
+  test_constructor_named() async {
     addTestFile('''
 class A {
   A.named(BBB p) {}
 }
 class BBB {}
 ''');
-    return prepareNavigation().then((_) {
-      // has region for complete "A.named"
-      assertHasRegionString('A.named');
-      assertHasTarget('named(BBB');
-      // no separate regions for "A" and "named"
-      assertNoRegion('A.named(', 'A'.length);
-      assertNoRegion('named(', 'named'.length);
-      // validate that we don't forget to resolve parameters
-      assertHasRegionTarget('BBB p', 'BBB {}');
-    });
+    await prepareNavigation();
+    // has region for complete "A.named"
+    assertHasRegionString('A.named');
+    assertHasTarget('named(BBB');
+    // no separate regions for "A" and "named"
+    assertNoRegion('A.named(', 'A'.length);
+    assertNoRegion('named(', 'named'.length);
+    // validate that we don't forget to resolve parameters
+    assertHasRegionTarget('BBB p', 'BBB {}');
   }
 
-  test_constructor_unnamed() {
+  test_constructor_unnamed() async {
     addTestFile('''
 class A {
   A(BBB p) {}
 }
 class BBB {}
 ''');
-    return prepareNavigation().then((_) {
-      // has region for complete "A.named"
-      assertHasRegion("A(BBB");
-      assertHasTarget("A(BBB", 0);
-      // validate that we don't forget to resolve parameters
-      assertHasRegionTarget('BBB p', 'BBB {}');
-    });
+    await prepareNavigation();
+    // has region for complete "A.named"
+    assertHasRegion("A(BBB");
+    assertHasTarget("A(BBB", 0);
+    // validate that we don't forget to resolve parameters
+    assertHasRegionTarget('BBB p', 'BBB {}');
   }
 
-  test_factoryRedirectingConstructor_implicit() {
+  test_factoryRedirectingConstructor_implicit() async {
     addTestFile('''
 class A {
   factory A() = B;
 }
 class B {
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegion('B;');
-      assertHasTarget('B {');
-    });
+    await prepareNavigation();
+    assertHasRegion('B;');
+    assertHasTarget('B {');
   }
 
-  test_factoryRedirectingConstructor_implicit_withTypeArgument() {
+  test_factoryRedirectingConstructor_implicit_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B {
   factory B() = C<A>;
 }
 class C<T> {}
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegion('C<A>');
-        assertHasTarget('C<T> {');
-      }
-      {
-        assertHasRegion('A>;');
-        assertHasTarget('A {');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegion('C<A>');
+      assertHasTarget('C<T> {');
+    }
+    {
+      assertHasRegion('A>;');
+      assertHasTarget('A {');
+    }
   }
 
-  test_factoryRedirectingConstructor_named() {
+  test_factoryRedirectingConstructor_named() async {
     addTestFile('''
 class A {
   factory A() = B.named;
 }
 class B {
   B.named();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('B.named;', 'B'.length);
-        assertHasTarget('named();');
-      }
-      {
-        assertHasRegionString('named;', 'named'.length);
-        assertHasTarget('named();');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegionString('B.named;', 'B'.length);
+      assertHasTarget('named();');
+    }
+    {
+      assertHasRegionString('named;', 'named'.length);
+      assertHasTarget('named();');
+    }
   }
 
-  test_factoryRedirectingConstructor_named_withTypeArgument() {
+  test_factoryRedirectingConstructor_named_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B {
   factory B.named() = C<A>.named;
 }
 class C<T> {
   C.named() {}
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegion('C<A>');
-        assertHasTarget('named() {}');
-      }
-      {
-        assertHasRegion('A>.named');
-        assertHasTarget('A {');
-      }
-      {
-        assertHasRegion('named;', 'named'.length);
-        assertHasTarget('named() {}');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegion('C<A>');
+      assertHasTarget('named() {}');
+    }
+    {
+      assertHasRegion('A>.named');
+      assertHasTarget('A {');
+    }
+    {
+      assertHasRegion('named;', 'named'.length);
+      assertHasTarget('named() {}');
+    }
   }
 
-  test_factoryRedirectingConstructor_unnamed() {
+  test_factoryRedirectingConstructor_unnamed() async {
     addTestFile('''
 class A {
   factory A() = B;
 }
 class B {
   B() {}
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegion('B;');
-      assertHasTarget('B() {}', 0);
-    });
+    await prepareNavigation();
+    assertHasRegion('B;');
+    assertHasTarget('B() {}', 0);
   }
 
-  test_factoryRedirectingConstructor_unnamed_withTypeArgument() {
+  test_factoryRedirectingConstructor_unnamed_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B {
   factory B() = C<A>;
 }
 class C<T> {
   C() {}
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegion('C<A>');
-        assertHasTarget('C() {}', 0);
-      }
-      {
-        assertHasRegion('A>;');
-        assertHasTarget('A {');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegion('C<A>');
+      assertHasTarget('C() {}', 0);
+    }
+    {
+      assertHasRegion('A>;');
+      assertHasTarget('A {');
+    }
   }
 
-  test_factoryRedirectingConstructor_unresolved() {
+  test_factoryRedirectingConstructor_unresolved() async {
     addTestFile('''
 class A {
   factory A() = B;
 }
 ''');
-    return prepareNavigation().then((_) {
-      // don't check regions, but there should be no exceptions
-    });
+    await prepareNavigation();
+    // don't check regions, but there should be no exceptions
   }
 
-  test_fieldFormalParameter() {
+  test_fieldFormalParameter() async {
     addTestFile('''
 class AAA {
   int fff = 123;
   AAA(this.fff);
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionTarget('fff);', 'fff = 123');
-    });
+    await prepareNavigation();
+    assertHasRegionTarget('fff);', 'fff = 123');
   }
 
-  test_fieldFormalParameter_unresolved() {
+  test_fieldFormalParameter_unresolved() async {
     addTestFile('''
 class AAA {
   AAA(this.fff);
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegion('fff);', 3);
-    });
+    await prepareNavigation();
+    assertNoRegion('fff);', 3);
   }
 
-  test_identifier_resolved() {
+  test_identifier_resolved() async {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
   print(aaa);
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionTarget('AAA aaa', 'AAA {}');
-      assertHasRegionTarget('aaa);', 'aaa = null');
-      assertHasRegionTarget('main() {', 'main() {');
-    });
+    await prepareNavigation();
+    assertHasRegionTarget('AAA aaa', 'AAA {}');
+    assertHasRegionTarget('aaa);', 'aaa = null');
+    assertHasRegionTarget('main() {', 'main() {');
   }
 
-  test_identifier_unresolved() {
+  test_identifier_unresolved() async {
     addTestFile('''
 main() {
   print(vvv);
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegionString('vvv');
-    });
+    await prepareNavigation();
+    assertNoRegionString('vvv');
   }
 
-  test_identifier_whenStrayImportDirective() {
+  test_identifier_whenStrayImportDirective() async {
     addTestFile('''
 main() {
   int aaa = 42;
   print(aaa);
 }
 import 'dart:math';
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionTarget('aaa);', 'aaa = 42');
-    });
+    await prepareNavigation();
+    assertHasRegionTarget('aaa);', 'aaa = 42');
   }
 
   test_inComment() async {
     addTestFile('''
 class FirstClass {}
 class SecondClass {
   /**
    * Return a [FirstClass] object equivalent to this object in every other way.
    */
   convert() {
     return new FirstClass();
   }
 }
 ''');
     await prepareNavigation();
     assertHasRegionTarget('FirstClass]', 'FirstClass {');
     assertHasRegionTarget('FirstClass(', 'FirstClass {');
   }
 
-  test_instanceCreation_implicit() {
+  test_instanceCreation_implicit() async {
     addTestFile('''
 class A {
 }
 main() {
   new A();
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('A()', 'A'.length);
-      assertHasTarget('A {');
-    });
+    await prepareNavigation();
+    assertHasRegionString('A()', 'A'.length);
+    assertHasTarget('A {');
   }
 
-  test_instanceCreation_implicit_withTypeArgument() {
+  test_instanceCreation_implicit_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B<T> {}
 main() {
   new B<A>();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegion('B<A>', 'B'.length);
-        assertHasTarget('B<T> {');
-      }
-      {
-        assertHasRegion('A>();', 'A'.length);
-        assertHasTarget('A {');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegion('B<A>', 'B'.length);
+      assertHasTarget('B<T> {');
+    }
+    {
+      assertHasRegion('A>();', 'A'.length);
+      assertHasTarget('A {');
+    }
   }
 
-  test_instanceCreation_named() {
+  test_instanceCreation_named() async {
     addTestFile('''
 class A {
   A.named() {}
 }
 main() {
   new A.named();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('A.named();', 'A'.length);
-        assertHasTarget('named() {}');
-      }
-      {
-        assertHasRegionString('named();', 'named'.length);
-        assertHasTarget('named() {}');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegionString('A.named();', 'A'.length);
+      assertHasTarget('named() {}');
+    }
+    {
+      assertHasRegionString('named();', 'named'.length);
+      assertHasTarget('named() {}');
+    }
   }
 
-  test_instanceCreation_named_withTypeArgument() {
+  test_instanceCreation_named_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B<T> {
   B.named() {}
 }
 main() {
   new B<A>.named();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('B<A>', 'B'.length);
-        assertHasTarget('named() {}');
-      }
-      {
-        assertHasRegion('A>.named');
-        assertHasTarget('A {');
-      }
-      {
-        assertHasRegion('named();', 'named'.length);
-        assertHasTarget('named() {}');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegionString('B<A>', 'B'.length);
+      assertHasTarget('named() {}');
+    }
+    {
+      assertHasRegion('A>.named');
+      assertHasTarget('A {');
+    }
+    {
+      assertHasRegion('named();', 'named'.length);
+      assertHasTarget('named() {}');
+    }
   }
 
-  test_instanceCreation_unnamed() {
+  test_instanceCreation_unnamed() async {
     addTestFile('''
 class A {
   A() {}
 }
 main() {
   new A();
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('A();', 'A'.length);
-      assertHasTarget('A() {}', 0);
-    });
+    await prepareNavigation();
+    assertHasRegionString('A();', 'A'.length);
+    assertHasTarget('A() {}', 0);
   }
 
-  test_instanceCreation_unnamed_withTypeArgument() {
+  test_instanceCreation_unnamed_withTypeArgument() async {
     addTestFile('''
 class A {}
 class B<T> {
   B() {}
 }
 main() {
   new B<A>();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('B<A>();', 'B'.length);
-        assertHasTarget('B() {}', 0);
-      }
-      {
-        assertHasRegion('A>();');
-        assertHasTarget('A {');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegionString('B<A>();', 'B'.length);
+      assertHasTarget('B() {}', 0);
+    }
+    {
+      assertHasRegion('A>();');
+      assertHasTarget('A {');
+    }
   }
 
-  test_library() {
+  test_library() async {
     addTestFile('''
 library my.lib;
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('my.lib');
-      assertHasTargetString('my.lib');
-    });
+    await prepareNavigation();
+    assertHasRegionString('my.lib');
+    assertHasTargetString('my.lib');
   }
 
-  test_multiplyDefinedElement() {
+  test_multiplyDefinedElement() async {
     addFile('$projectPath/bin/libA.dart', 'library A; int TEST = 1;');
     addFile('$projectPath/bin/libB.dart', 'library B; int TEST = 2;');
     addTestFile('''
 import 'libA.dart';
 import 'libB.dart';
 main() {
   TEST;
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegionAt('TEST');
-    });
+    await prepareNavigation();
+    assertNoRegionAt('TEST');
   }
 
-  test_operator_arithmetic() {
+  test_operator_arithmetic() async {
     addTestFile('''
 class A {
   A operator +(other) => null;
   A operator -() => null;
   A operator -(other) => null;
   A operator *(other) => null;
   A operator /(other) => null;
 }
 main() {
   var a = new A();
   a - 1;
   a + 2;
   -a; // unary
   --a;
   ++a;
   a--; // mm
   a++; // pp
   a -= 3;
   a += 4;
   a *= 5;
   a /= 6;
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasOperatorRegion('- 1', 1, '-(other) => null', 1);
-      assertHasOperatorRegion('+ 2', 1, '+(other) => null', 1);
-      assertHasOperatorRegion('-a; // unary', 1, '-() => null', 1);
-      assertHasOperatorRegion('--a;', 2, '-(other) => null', 1);
-      assertHasOperatorRegion('++a;', 2, '+(other) => null', 1);
-      assertHasOperatorRegion('--; // mm', 2, '-(other) => null', 1);
-      assertHasOperatorRegion('++; // pp', 2, '+(other) => null', 1);
-      assertHasOperatorRegion('-= 3', 2, '-(other) => null', 1);
-      assertHasOperatorRegion('+= 4', 2, '+(other) => null', 1);
-      assertHasOperatorRegion('*= 5', 2, '*(other) => null', 1);
-      assertHasOperatorRegion('/= 6', 2, '/(other) => null', 1);
-    });
+    await prepareNavigation();
+    assertHasOperatorRegion('- 1', 1, '-(other) => null', 1);
+    assertHasOperatorRegion('+ 2', 1, '+(other) => null', 1);
+    assertHasOperatorRegion('-a; // unary', 1, '-() => null', 1);
+    assertHasOperatorRegion('--a;', 2, '-(other) => null', 1);
+    assertHasOperatorRegion('++a;', 2, '+(other) => null', 1);
+    assertHasOperatorRegion('--; // mm', 2, '-(other) => null', 1);
+    assertHasOperatorRegion('++; // pp', 2, '+(other) => null', 1);
+    assertHasOperatorRegion('-= 3', 2, '-(other) => null', 1);
+    assertHasOperatorRegion('+= 4', 2, '+(other) => null', 1);
+    assertHasOperatorRegion('*= 5', 2, '*(other) => null', 1);
+    assertHasOperatorRegion('/= 6', 2, '/(other) => null', 1);
   }
 
-  test_operator_index() {
+  test_operator_index() async {
     addTestFile('''
 class A {
   A operator +(other) => null;
 }
 class B {
   A operator [](index) => null;
   operator []=(index, A value) {}
 }
 main() {
   var b = new B();
   b[0] // [];
   b[1] = 1; // []=;
   b[2] += 2;
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasOperatorRegion('[0', 1, '[](index)', 2);
-      assertHasOperatorRegion('] // []', 1, '[](index)', 2);
-      assertHasOperatorRegion('[1', 1, '[]=(index,', 3);
-      assertHasOperatorRegion('] = 1;', 1, '[]=(index,', 3);
-      assertHasOperatorRegion('[2', 1, '[]=(index,', 3);
-      assertHasOperatorRegion('] += 2;', 1, '[]=(index,', 3);
-      assertHasOperatorRegion('+= 2;', 2, '+(other)', 1);
-    });
+    await prepareNavigation();
+    assertHasOperatorRegion('[0', 1, '[](index)', 2);
+    assertHasOperatorRegion('] // []', 1, '[](index)', 2);
+    assertHasOperatorRegion('[1', 1, '[]=(index,', 3);
+    assertHasOperatorRegion('] = 1;', 1, '[]=(index,', 3);
+    assertHasOperatorRegion('[2', 1, '[]=(index,', 3);
+    assertHasOperatorRegion('] += 2;', 1, '[]=(index,', 3);
+    assertHasOperatorRegion('+= 2;', 2, '+(other)', 1);
   }
 
-  test_partOf() {
+  test_partOf() async {
     var libCode = 'library lib; part "test.dart";';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('part of lib;');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('lib');
-      assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
-    });
+    await prepareNavigation();
+    assertHasRegionString('lib');
+    assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
   }
 
-  test_redirectingConstructorInvocation() {
+  test_redirectingConstructorInvocation() async {
     addTestFile('''
 class A {
   A() {}
   A.foo() : this();
   A.bar() : this.foo();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegion('this();');
-        assertHasTarget('A() {}', 0);
-      }
-      {
-        assertHasRegion('this.foo');
-        assertHasTarget('foo() :');
-      }
-      {
-        assertHasRegion('foo();');
-        assertHasTarget('foo() :');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegion('this();');
+      assertHasTarget('A() {}', 0);
+    }
+    {
+      assertHasRegion('this.foo');
+      assertHasTarget('foo() :');
+    }
+    {
+      assertHasRegion('foo();');
+      assertHasTarget('foo() :');
+    }
   }
 
-  test_string_export() {
+  test_string_export() async {
     var libCode = 'library lib;';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('export "lib.dart";');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('"lib.dart"');
-      assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
-    });
+    await prepareNavigation();
+    assertHasRegionString('"lib.dart"');
+    assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
   }
 
-  test_string_export_unresolvedUri() {
+  test_string_export_unresolvedUri() async {
     addTestFile('export "no.dart";');
-    return prepareNavigation().then((_) {
-      assertNoRegionString('"no.dart"');
-    });
+    await prepareNavigation();
+    assertNoRegionString('"no.dart"');
   }
 
-  test_string_import() {
+  test_string_import() async {
     var libCode = 'library lib;';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('import "lib.dart";');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('"lib.dart"');
-      assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
-    });
+    await prepareNavigation();
+    assertHasRegionString('"lib.dart"');
+    assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
   }
 
-  test_string_import_noUri() {
+  test_string_import_noUri() async {
     addTestFile('import ;');
-    return prepareNavigation().then((_) {
-      assertNoRegionAt('import ;');
-    });
+    await prepareNavigation();
+    assertNoRegionAt('import ;');
   }
 
-  test_string_import_unresolvedUri() {
+  test_string_import_unresolvedUri() async {
     addTestFile('import "no.dart";');
-    return prepareNavigation().then((_) {
-      assertNoRegionString('"no.dart"');
-    });
+    await prepareNavigation();
+    assertNoRegionString('"no.dart"');
   }
 
-  test_string_part() {
+  test_string_part() async {
     var unitCode = 'part of lib;  f() {}';
     var unitFile = addFile('$projectPath/bin/test_unit.dart', unitCode);
     addTestFile('''
 library lib;
 part "test_unit.dart";
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionString('"test_unit.dart"');
-      assertHasFileTarget(unitFile, 0, 0);
-    });
+    await prepareNavigation();
+    assertHasRegionString('"test_unit.dart"');
+    assertHasFileTarget(unitFile, 0, 0);
   }
 
-  test_string_part_unresolvedUri() {
+  test_string_part_unresolvedUri() async {
     addTestFile('''
 library lib;
 part "test_unit.dart";
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegionString('"test_unit.dart"');
-    });
+    await prepareNavigation();
+    assertNoRegionString('"test_unit.dart"');
   }
 
-  test_superConstructorInvocation() {
+  test_superConstructorInvocation() async {
     addTestFile('''
 class A {
   A() {}
   A.named() {}
 }
 class B extends A {
   B() : super();
   B.named() : super.named();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('super');
-        assertHasTarget('A() {}', 0);
-      }
-      {
-        assertHasRegion('super.named');
-        assertHasTarget('named() {}');
-      }
-      {
-        assertHasRegion('named();');
-        assertHasTarget('named() {}');
-      }
-    });
+    await prepareNavigation();
+    {
+      assertHasRegionString('super');
+      assertHasTarget('A() {}', 0);
+    }
+    {
+      assertHasRegion('super.named');
+      assertHasTarget('named() {}');
+    }
+    {
+      assertHasRegion('named();');
+      assertHasTarget('named() {}');
+    }
   }
 
-  test_superConstructorInvocation_synthetic() {
+  test_superConstructorInvocation_synthetic() async {
     addTestFile('''
 class A {
 }
 class B extends A {
   B() : super();
 }
 ''');
-    return prepareNavigation().then((_) {
-      {
-        assertHasRegionString('super');
-        assertHasTarget('A {');
-      }
-    });
+    await prepareNavigation();
+    assertHasRegionString('super');
+    assertHasTarget('A {');
   }
 
-  test_targetElement() {
+  test_targetElement() async {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertHasRegionTarget('AAA aaa', 'AAA {}');
-      expect(testTarget.kind, ElementKind.CLASS);
-    });
+    await prepareNavigation();
+    assertHasRegionTarget('AAA aaa', 'AAA {}');
+    expect(testTarget.kind, ElementKind.CLASS);
   }
 
-  test_type_dynamic() {
+  test_type_dynamic() async {
     addTestFile('''
 main() {
   dynamic v = null;
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegionAt('dynamic');
-    });
+    await prepareNavigation();
+    assertNoRegionAt('dynamic');
   }
 
-  test_type_void() {
+  test_type_void() async {
     addTestFile('''
 void main() {
 }
 ''');
-    return prepareNavigation().then((_) {
-      assertNoRegionAt('void');
-    });
+    await prepareNavigation();
+    assertNoRegionAt('void');
   }
 }