Use async/await in all analysis domain tests.

pkg/analysis_server/test/analysis/notification_overrides_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.overrides;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 103 matching lines @@
         overridesList = params.overrides;
       }
     }
   }
 
   void setUp() {
     super.setUp();
     createProject();
   }
 
-  test_afterAnalysis() {
+  test_afterAnalysis() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {
   m() {} // in B
 }
 ''');
-    return waitForTasksFinished().then((_) {
-      return prepareOverrides().then((_) {
-        assertHasOverride('m() {} // in B');
-        assertNoSuperMember();
-        assertHasInterfaceMember('m() {} // in A');
-      });
-    });
+    await waitForTasksFinished();
+    await prepareOverrides();
+    assertHasOverride('m() {} // in B');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in A');
   }
 
-  test_definedInInterface_ofInterface() {
+  test_definedInInterface_ofInterface() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {}
 class C implements B {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      assertNoSuperMember();
-      assertHasInterfaceMember('m() {} // in A');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in A');
   }
 
-  test_definedInInterface_ofSuper() {
+  test_definedInInterface_ofSuper() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {}
 class C extends B {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      assertNoSuperMember();
-      assertHasInterfaceMember('m() {} // in A');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in A');
   }
 
-  test_interface_method_direct_multiple() {
+  test_interface_method_direct_multiple() async {
     addTestFile('''
 class IA {
   m() {} // in IA
 }
 class IB {
   m() {} // in IB
 }
 class A implements IA, IB {
   m() {} // in A
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in A');
-      assertNoSuperMember();
-      assertHasInterfaceMember('m() {} // in IA');
-      assertHasInterfaceMember('m() {} // in IB');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in A');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in IA');
+    assertHasInterfaceMember('m() {} // in IB');
   }
 
-  test_interface_method_direct_single() {
+  test_interface_method_direct_single() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B implements A {
   m() {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in B');
-      assertNoSuperMember();
-      assertHasInterfaceMember('m() {} // in A');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in B');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in A');
   }
 
-  test_interface_method_indirect_single() {
+  test_interface_method_indirect_single() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
 }
 class C implements B {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      assertNoSuperMember();
-      assertHasInterfaceMember('m() {} // in A');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    assertNoSuperMember();
+    assertHasInterfaceMember('m() {} // in A');
   }
 
-  test_interface_stopWhenFound() {
+  test_interface_stopWhenFound() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
   m() {} // in B
 }
 class C implements B {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      expect(override.interfaceMembers, hasLength(1));
-      assertHasInterfaceMember('m() {} // in B');
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    expect(override.interfaceMembers, hasLength(1));
+    assertHasInterfaceMember('m() {} // in B');
   }
 
-  test_mix_sameMethod() {
+  test_mix_sameMethod() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 abstract class B extends A {
 }
 class C extends A implements A {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      assertHasSuperElement('m() {} // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    assertHasSuperElement('m() {} // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_mix_sameMethod_Object_hashCode() {
+  test_mix_sameMethod_Object_hashCode() async {
     addTestFile('''
 class A {}
 abstract class B {}
 class C extends A implements A {
   int get hashCode => 42;
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('hashCode => 42;');
-      expect(override.superclassMember, isNotNull);
-      expect(override.interfaceMembers, isNull);
-    });
+    await prepareOverrides();
+    assertHasOverride('hashCode => 42;');
+    expect(override.superclassMember, isNotNull);
+    expect(override.interfaceMembers, isNull);
   }
 
-  test_staticMembers() {
+  test_staticMembers() async {
     addTestFile('''
 class A {
   static int F = 0;
   static void M() {}
   static int get G => 0;
   static void set S(int v) {}
 }
 class B extends A {
   static int F = 0;
   static void M() {}
   static int get G => 0;
   static void set S(int v) {}
 }
 ''');
-    return prepareOverrides().then((_) {
-      expect(overridesList, isEmpty);
-    });
+    await prepareOverrides();
+    expect(overridesList, isEmpty);
   }
 
-  test_super_fieldByField() {
+  test_super_fieldByField() async {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   int fff; // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff; // in B');
-      assertHasSuperElement('fff; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff; // in B');
+    assertHasSuperElement('fff; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_fieldByGetter() {
+  test_super_fieldByGetter() async {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   get fff => 0; // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff => 0; // in B');
-      assertHasSuperElement('fff; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff => 0; // in B');
+    assertHasSuperElement('fff; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_fieldByMethod() {
+  test_super_fieldByMethod() async {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   fff() {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff() {} // in B');
-      assertHasSuperElement('fff; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff() {} // in B');
+    assertHasSuperElement('fff; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_fieldBySetter() {
+  test_super_fieldBySetter() async {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   set fff(x) {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff(x) {} // in B');
-      assertHasSuperElement('fff; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff(x) {} // in B');
+    assertHasSuperElement('fff; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_getterByField() {
+  test_super_getterByField() async {
     addTestFile('''
 class A {
   get fff => 0; // in A
   set fff(x) {} // in A
 }
 class B extends A {
   int fff; // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff; // in B');
-      assertHasSuperElement('fff => 0; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff; // in B');
+    assertHasSuperElement('fff => 0; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_getterByGetter() {
+  test_super_getterByGetter() async {
     addTestFile('''
 class A {
   get fff => 0; // in A
 }
 class B extends A {
   get fff => 0; // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff => 0; // in B');
-      assertHasSuperElement('fff => 0; // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff => 0; // in B');
+    assertHasSuperElement('fff => 0; // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_method_direct() {
+  test_super_method_direct() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
   m() {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in B');
-      assertHasSuperElement('m() {} // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in B');
+    assertHasSuperElement('m() {} // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_method_indirect() {
+  test_super_method_indirect() async {
     addTestFile('''
 class A {
   m() {} // in A
 }
 class B extends A {
 }
 class C extends B {
   m() {} // in C
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('m() {} // in C');
-      assertHasSuperElement('m() {} // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('m() {} // in C');
+    assertHasSuperElement('m() {} // in A');
+    assertNoInterfaceMembers();
   }
 
-  test_super_method_superTypeCycle() {
+  test_super_method_superTypeCycle() async {
     addTestFile('''
 class A extends B {
   m() {} // in A
 }
 class B extends A {
   m() {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      // must finish
-    });
+    await prepareOverrides();
+    // must finish
   }
 
-  test_super_setterBySetter() {
+  test_super_setterBySetter() async {
     addTestFile('''
 class A {
   set fff(x) {} // in A
 }
 class B extends A {
   set fff(x) {} // in B
 }
 ''');
-    return prepareOverrides().then((_) {
-      assertHasOverride('fff(x) {} // in B');
-      assertHasSuperElement('fff(x) {} // in A');
-      assertNoInterfaceMembers();
-    });
+    await prepareOverrides();
+    assertHasOverride('fff(x) {} // in B');
+    assertHasSuperElement('fff(x) {} // in A');
+    assertNoInterfaceMembers();
   }
 }