Run the rest of the analysis tests with the new analysis driver.

pkg/analyzer/test/generated/simple_resolver_test.dart

 // Copyright (c) 2016, 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 analyzer.test.generated.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 257 matching lines @@
     String text = r'''
 void f() {
   loop1: while (true) {
     loop2: for (int i = 0; i < 10; i++) {
       break loop1;
       break loop2;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while (true)', (n) => n is WhileStatement);
     ForStatement forStatement =
         EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     BreakStatement break1 = EngineTestCase.findNode(
         unit, text, 'break loop1', (n) => n is BreakStatement);
     BreakStatement break2 = EngineTestCase.findNode(
         unit, text, 'break loop2', (n) => n is BreakStatement);
     expect(break1.target, same(whileStatement));
     expect(break2.target, same(forStatement));
   }
 
   test_breakTarget_unlabeledBreakFromDo() async {
     String text = r'''
 void f() {
   do {
     break;
   } while (true);
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     DoStatement doStatement =
         EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(doStatement));
   }
 
   test_breakTarget_unlabeledBreakFromFor() async {
     String text = r'''
 void f() {
   for (int i = 0; i < 10; i++) {
     break;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     ForStatement forStatement =
         EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(forStatement));
   }
 
   test_breakTarget_unlabeledBreakFromForEach() async {
     String text = r'''
 void f() {
   for (x in []) {
     break;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     ForEachStatement forStatement = EngineTestCase.findNode(
         unit, text, 'for', (n) => n is ForEachStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(forStatement));
   }
 
   test_breakTarget_unlabeledBreakFromSwitch() async {
     String text = r'''
 void f() {
   while (true) {
     switch (0) {
       case 0:
         break;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     SwitchStatement switchStatement = EngineTestCase.findNode(
         unit, text, 'switch', (n) => n is SwitchStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(switchStatement));
   }
 
   test_breakTarget_unlabeledBreakFromWhile() async {
     String text = r'''
 void f() {
   while (true) {
     break;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while', (n) => n is WhileStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(whileStatement));
   }
 
   test_breakTarget_unlabeledBreakToOuterFunction() async {
     // Verify that unlabeled break statements can't resolve to loops in an
     // outer function.
     String text = r'''
 void f() {
   while (true) {
     void g() {
       break;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, isNull);
   }
 
   test_class_definesCall() async {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
@@ skipping 57 matching lines @@
     String text = r'''
 void f() {
   loop1: while (true) {
     loop2: for (int i = 0; i < 10; i++) {
       continue loop1;
       continue loop2;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while (true)', (n) => n is WhileStatement);
     ForStatement forStatement =
         EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     ContinueStatement continue1 = EngineTestCase.findNode(
         unit, text, 'continue loop1', (n) => n is ContinueStatement);
     ContinueStatement continue2 = EngineTestCase.findNode(
         unit, text, 'continue loop2', (n) => n is ContinueStatement);
     expect(continue1.target, same(whileStatement));
     expect(continue2.target, same(forStatement));
   }
 
   test_continueTarget_unlabeledContinueFromDo() async {
     String text = r'''
 void f() {
   do {
     continue;
   } while (true);
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     DoStatement doStatement =
         EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(doStatement));
   }
 
   test_continueTarget_unlabeledContinueFromFor() async {
     String text = r'''
 void f() {
   for (int i = 0; i < 10; i++) {
     continue;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     ForStatement forStatement =
         EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(forStatement));
   }
 
   test_continueTarget_unlabeledContinueFromForEach() async {
     String text = r'''
 void f() {
   for (x in []) {
     continue;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     ForEachStatement forStatement = EngineTestCase.findNode(
         unit, text, 'for', (n) => n is ForEachStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(forStatement));
   }
 
   test_continueTarget_unlabeledContinueFromWhile() async {
     String text = r'''
 void f() {
   while (true) {
     continue;
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while', (n) => n is WhileStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(whileStatement));
   }
 
   test_continueTarget_unlabeledContinueSkipsSwitch() async {
     String text = r'''
 void f() {
   while (true) {
     switch (0) {
       case 0:
         continue;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while', (n) => n is WhileStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(whileStatement));
   }
 
   test_continueTarget_unlabeledContinueToOuterFunction() async {
     // Verify that unlabeled continue statements can't resolve to loops in an
     // outer function.
     String text = r'''
 void f() {
   while (true) {
     void g() {
       continue;
     }
   }
 }
 ''';
-    CompilationUnit unit = resolveSource(text);
+    CompilationUnit unit = await resolveSource(text);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, isNull);
   }
 
   test_empty() async {
     Source source = addSource("");
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 1321 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }