Use futures uniformly rather than a mix of futures and CPS in 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.domain.analysis.notification.navigation;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/computer/element.dart';
@@ skipping 19 matching lines @@
   List<Element> testTargets;
   Element testTarget;
 
   /**
    * Validates that there is a target in [testTargets]  with [file], at [offset]
    * and with the given [length].
    */
   void assertHasFileTarget(String file, int offset, int length) {
     for (Element target in testTargets) {
       Location location = target.location;
-      if (location.file == file && location.offset == offset && location.length ==
-          length) {
+      if (location.file == file &&
+          location.offset == offset &&
+          location.length == length) {
         testTarget = target;
         return;
       }
     }
     fail(
         'Expected to find target (file=$file; offset=$offset; length=$length) in\n'
-        '${testRegion} in\n' '${regions.join('\n')}');
+            '${testRegion} in\n' '${regions.join('\n')}');
   }
 
   void assertHasOperatorRegion(String regionSearch, int regionLength,
       String targetSearch, int targetLength) {
     assertHasRegion(regionSearch, regionLength);
     assertHasTarget(targetSearch, targetLength);
   }
 
   /**
    * Validates that there is a region at the offset of [search] in [testFile].
@@ skipping 71 matching lines @@
    * If [length] is `-1`, then it is ignored.
    *
    * If [exists] is `true`, then fails if such region does not exist.
    * Otherwise remembers this it into [testRegion].
    * Also fills [testTargets] with its targets.
    *
    * If [exists] is `false`, then fails if such region exists.
    */
   void findRegion(int offset, int length, [bool exists]) {
     for (NavigationRegion region in regions) {
-      if (region.offset == offset && (length == -1 || region.length == length))
-          {
+      if (region.offset == offset &&
+          (length == -1 || region.length == length)) {
         if (exists == false) {
-          fail('Not expected to find (offset=$offset; length=$length) in\n'
-              '${regions.join('\n')}');
+          fail(
+              'Not expected to find (offset=$offset; length=$length) in\n'
+                  '${regions.join('\n')}');
         }
         testRegion = region;
         testTargets = region.targets;
         return;
       }
     }
     if (exists == true) {
-      fail('Expected to find (offset=$offset; length=$length) in\n'
-          '${regions.join('\n')}');
+      fail(
+          'Expected to find (offset=$offset; length=$length) in\n'
+              '${regions.join('\n')}');
     }
   }
 
-  Future prepareNavigation(then()) {
+  Future prepareNavigation() {
     addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
-    return waitForTasksFinished().then((_) {
-      then();
-    });
+    return waitForTasksFinished();
   }
 
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_NAVIGATION) {
       String file = notification.getParameter(FILE);
       if (file == testFile) {
         regions = <NavigationRegion>[];
-        List<Map<String, Object>> regionsJson = notification.getParameter(
-            REGIONS);
+        List<Map<String, Object>> regionsJson =
+            notification.getParameter(REGIONS);
         for (Map<String, Object> regionJson in regionsJson) {
           var regionOffset = regionJson[OFFSET];
           var regionLength = regionJson[LENGTH];
           List<Element> targets = <Element>[];
           for (Map<String, Object> targetJson in regionJson[TARGETS]) {
             targets.add(new Element.fromJson(targetJson));
           }
-          var region = new NavigationRegion(regionOffset, regionLength,
-              targets);
+          var region =
+              new NavigationRegion(regionOffset, regionLength, targets);
           regions.add(region);
         }
       }
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     createProject();
   }
 
   test_afterAnalysis() {
     addTestFile('''
 class AAA {}
 AAA aaa;
 ''');
     return waitForTasksFinished().then((_) {
-      return prepareNavigation(() {
+      return prepareNavigation().then((_) {
         assertHasRegionTarget('AAA aaa;', 'AAA {}');
       });
     });
   }
 
   test_constructor_named() {
     addTestFile('''
 class A {
   A.named(BBB p) {}
 }
 class BBB {}
 ''');
-    return prepareNavigation(() {
+    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 {}');
     });
   }
 
   test_constructor_unnamed() {
     addTestFile('''
 class A {
   A(BBB p) {}
 }
 class BBB {}
 ''');
-    return prepareNavigation(() {
+    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 {}');
     });
   }
 
   test_fieldFormalParameter() {
     addTestFile('''
 class AAA {
   int fff = 123;
   AAA(this.fff);
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionTarget('fff);', 'fff = 123');
     });
   }
 
   test_identifier_resolved() {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
   print(aaa);
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionTarget('AAA aaa', 'AAA {}');
       assertHasRegionTarget('aaa);', 'aaa = null');
       assertHasRegionTarget('main() {', 'main() {');
     });
   }
 
   test_identifier_unresolved() {
     addTestFile('''
 main() {
   print(vvv);
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertNoRegionString('vvv');
     });
   }
 
   test_instanceCreation_implicit() {
     addTestFile('''
 class A {
 }
 main() {
   new A();
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('new A');
       assertHasTarget('A {');
     });
   }
 
   test_instanceCreation_named() {
     addTestFile('''
 class A {
   A.named() {}
 }
 main() {
   new A.named();
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('new A.named');
       assertHasTarget('named() {}');
     });
   }
 
   test_instanceCreation_unnamed() {
     addTestFile('''
 class A {
   A() {}
 }
 main() {
   new A();
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('new A');
       assertHasTarget("A() {}", 0);
     });
   }
 
   test_operator_arithmetic() {
     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(() {
+    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);
@@ skipping 10 matching lines @@
   A operator [](index) => null;
   operator []=(index, A value) {}
 }
 main() {
   var b = new B();
   b[0] // [];
   b[1] = 1; // []=;
   b[2] += 2;
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasOperatorRegion('] // []', 1, '[](index)', 2);
       assertHasOperatorRegion('] = 1;', 1, '[]=(index,', 3);
       assertHasOperatorRegion('] += 2;', 1, '[]=(index,', 3);
       assertHasOperatorRegion('+= 2;', 2, '+(other)', 1);
     });
   }
 
   test_partOf() {
     var libCode = 'library lib; part "test.dart";';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('part of lib;');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('part of lib');
       assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
     });
   }
 
   test_string_export() {
     var libCode = 'library lib;';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('export "lib.dart";');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('export "lib.dart"');
       assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
     });
   }
 
   test_string_export_unresolvedUri() {
     addTestFile('export "no.dart";');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertNoRegionString('export "no.dart"');
     });
   }
 
   test_string_import() {
     var libCode = 'library lib;';
     var libFile = addFile('$projectPath/bin/lib.dart', libCode);
     addTestFile('import "lib.dart";');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('import "lib.dart"');
       assertHasFileTarget(libFile, libCode.indexOf('lib;'), 'lib'.length);
     });
   }
 
   test_string_import_noUri() {
     addTestFile('import ;');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertNoRegionAt('import ;');
     });
   }
 
   test_string_import_unresolvedUri() {
     addTestFile('import "no.dart";');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertNoRegionString('import "no.dart"');
     });
   }
 
   test_string_part() {
     var unitCode = 'part of lib;  f() {}';
     var unitFile = addFile('$projectPath/bin/test_unit.dart', unitCode);
     addTestFile('''
 library lib;
 part "test_unit.dart";
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionString('part "test_unit.dart"');
       assertHasFileTarget(unitFile, 0, 0);
     });
   }
 
   test_string_part_unresolvedUri() {
     addTestFile('''
 library lib;
 part "test_unit.dart";
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertNoRegionString('part "test_unit.dart"');
     });
   }
 
   test_targetElement() {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
 }
 ''');
-    return prepareNavigation(() {
+    return prepareNavigation().then((_) {
       assertHasRegionTarget('AAA aaa', 'AAA {}');
       expect(testTarget.kind, ElementKind.CLASS);
       expect(testTarget.name, 'AAA');
       expect(testTarget.isAbstract, false);
       expect(testTarget.parameters, isNull);
       expect(testTarget.returnType, isNull);
     });
   }
 }
 
 
 class NavigationRegion {
   final int offset;
   final int length;
   final List<Element> targets;
 
   NavigationRegion(this.offset, this.length, this.targets);
 
   @override
   String toString() {
     return 'NavigationRegion(offset=$offset; length=$length; targets=$targets';
   }
 }