Properly close `setUpAll` and `tearDownAll` tests.

lib/src/runner/engine.dart

 // Copyright (c) 2015, 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.runner.engine;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async/async.dart' hide Result;
@@ skipping 114 matching lines @@
   final _skipped = new Set<LiveTest>();
 
   /// The set of tests that have completed and been marked as failing or error.
   Set<LiveTest> get failed => new UnmodifiableSetView(_failed);
   final _failed = new Set<LiveTest>();
 
   /// The tests that are still running, in the order they begain running.
   List<LiveTest> get active => new UnmodifiableListView(_active);
   final _active = new QueueList<LiveTest>();
 
+  /// The set of tests that have completed successfully but shouldn't be
+  /// displayed by the reporter.
+  ///
+  /// This includes load tests, `setUpAll`, and `tearDownAll`.
+  final _hidden = new Set<LiveTest>();
+
   /// The tests from [LoadSuite]s that are still running, in the order they
   /// began running.
   ///
   /// This is separate from [active] because load tests aren't always surfaced.
   final _activeLoadTests = new List<LiveTest>();
 
   /// Whether this engine is idle—that is, not currently executing a test.
   bool get isIdle => _group.isIdle;
 
   /// A broadcast stream that fires an event whenever [isIdle] switches from
@@ skipping 142 matching lines @@
 
       if (state.result != Result.success) {
         _passed.remove(liveTest);
         _failed.add(liveTest);
       } else if (liveTest.test.metadata.skip) {
         _skipped.add(liveTest);
       } else if (countSuccess) {
         _passed.add(liveTest);
       } else {
         _liveTests.remove(liveTest);
+        _hidden.add(liveTest);
       }
     });
 
     _onTestStartedController.add(liveTest);
 
     // First, schedule a microtask to ensure that [onTestStarted] fires before
     // the first [LiveTest.onStateChange] event. Once the test finishes, use
     // [new Future] to do a coarse-grained event loop pump to avoid starving
     // non-microtask events.
     await new Future.microtask(liveTest.run);
@@ skipping 25 matching lines @@
         _active.remove(liveTest);
         _liveTests.remove(liveTest);
 
         if (_activeLoadTests.isNotEmpty) {
           _active.add(_activeLoadTests.last);
           _liveTests.add(_activeLoadTests.last);
         }
       }
 
       // Surface the load test if it fails so that the user can see the failure.
-      if (state.result == Result.success) return;
-      _failed.add(liveTest);
-      _liveTests.add(liveTest);
+      if (state.result == Result.success) {
+        _hidden.add(liveTest);
+      } else {
+        _failed.add(liveTest);
+        _liveTests.add(liveTest);
+      }
     });
 
     // Run the test immediately. We don't want loading to be blocked on suites
     // that are already running.
     _onTestStartedController.add(liveTest);
     await liveTest.run();
 
     return suite.suite;
   }
 
   /// Signals that the caller is done paying attention to test results and the
   /// engine should release any resources it has allocated.
   ///
   /// Any actively-running tests are also closed. VM tests are allowed to finish
   /// running so that any modifications they've made to the filesystem can be
   /// cleaned up.
   ///
   /// **Note that closing the engine is not the same as closing [suiteSink].**
   /// Closing [suiteSink] indicates that no more input will be provided, closing
   /// the engine indicates that no more output should be emitted.
   Future close() async {
     _closed = true;
     if (_closedBeforeDone != null) _closedBeforeDone = true;
     _suiteController.close();
 
     // Close the running tests first so that we're sure to wait for them to
     // finish before we close their suites and cause them to become unloaded.
-    var allLiveTests = liveTests.toSet()..addAll(_activeLoadTests);
+    var allLiveTests = liveTests.toSet()
+      ..addAll(_activeLoadTests)
+      ..addAll(_hidden);
     var futures = allLiveTests.map((liveTest) => liveTest.close()).toList();
 
     // Closing the load pool will close the test suites as soon as their tests
     // are done. For browser suites this is effectively immediate since their
     // tests shut down as soon as they're closed, but for VM suites we may need
     // to wait for tearDowns or tearDownAlls to run.
     futures.add(_loadPool.close());
     await Future.wait(futures, eagerError: true);
   }
 }