Abort analysis server integration tests in the event of async errors.

pkg/analysis_testing/lib/reflective_tests.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 reflective_tests;
 
 import 'dart:async';
 
 @MirrorsUsed(metaTargets: 'ReflectiveTestCase')
 import 'dart:mirrors';
@@ skipping 27 matching lines @@
  * behavior, then `tearDown` will be invoked in `Future.complete`.
  */
 void runReflectiveTests(Type type) {
   ClassMirror classMirror = reflectClass(type);
   classMirror.instanceMembers.forEach((symbol, memberMirror) {
     // we need only methods
     if (memberMirror is! MethodMirror || !memberMirror.isRegularMethod) {
       return;
     }
     String memberName = MirrorSystem.getName(symbol);
+    wrapTest() {
+      var result = _runTest(classMirror, symbol);
+      if (result is Future) {
+        // We can't just return the future because of dartbug.com/20153.  So
+        // use expectAsync() to ensure that the test doesn't end until the
+        // future completes.  TODO(paulberry): get rid of this workaround once
+        // 20153 is fixed.
+        result.then(expectAsync((_) {}));
+      }
+    }
     // test_
     if (memberName.startsWith('test_')) {
       String testName = memberName.substring('test_'.length);
-      test(testName, () {
-        return _runTest(classMirror, symbol);
-      });
+      test(testName, wrapTest);
       return;
     }
     // solo_test_
     if (memberName.startsWith('solo_test_')) {
       String testName = memberName.substring('solo_test_'.length);
-      solo_test(testName, () {
-        return _runTest(classMirror, symbol);
-      });
+      solo_test(testName, wrapTest);
     }
   });
 }
 
 
 _runTest(ClassMirror classMirror, Symbol symbol) {
   InstanceMirror instanceMirror = classMirror.newInstance(new Symbol(''), []);
   return _invokeSymbolIfExists(instanceMirror, #setUp).then(
       (_) => instanceMirror.invoke(symbol, []).reflectee).whenComplete(
       () => _invokeSymbolIfExists(instanceMirror, #tearDown));
 }
 
 
 Future _invokeSymbolIfExists(InstanceMirror instanceMirror, Symbol symbol) {
   var invocationResult = null;
   try {
     invocationResult = instanceMirror.invoke(symbol, []).reflectee;
   } on NoSuchMethodError catch (e) {
   }
   if (invocationResult is Future) {
     return invocationResult;
   } else {
     return new Future.value(invocationResult);
   }
 }