Move some state-tracking to Engine.

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:collection/collection.dart';
 import 'package:pool/pool.dart';
 
 import '../backend/live_test.dart';
 import '../backend/live_test_controller.dart';
 import '../backend/state.dart';
 import '../backend/suite.dart';
 import '../backend/test.dart';
 import '../utils.dart';
 
 /// An [Engine] manages a run that encompasses multiple test suites.
@@ skipping 28 matching lines @@
   /// This allows test suites to be run in parallel without running multiple
   /// tests in the same suite at once.
   final List<List<LiveTest>> _liveTestsBySuite;
 
   /// A stream that emits each [LiveTest] as it's about to start running.
   ///
   /// This is guaranteed to fire before [LiveTest.onStateChange] first fires.
   Stream<LiveTest> get onTestStarted => _onTestStartedController.stream;
   final _onTestStartedController = new StreamController<LiveTest>.broadcast();
 
+  /// The set of tests that have completed and been marked as passing.
+  Set<LiveTest> get passed => new UnmodifiableSetView(_passed);
+  final _passed = new Set<LiveTest>();
+
+  /// The set of tests that have completed and been marked as skipped.
+  Set<LiveTest> get skipped => new UnmodifiableSetView(_skipped);
+  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 List<LiveTest>();
+
   /// Returns the tests in [suites] grouped by suite.
   ///
   /// Also replaces tests marked as "skip" with dummy [LiveTest]s.
   static List<List<LiveTest>> _computeLiveTestsBySuite(Iterable<Suite> suites) {
     return suites.map((suite) {
       return suite.tests.map((test) {
         return test.metadata.skip
             ? _skippedTest(suite, test)
             : test.load(suite);
       }).toList();
@@ skipping 29 matching lines @@
     _runCalled = true;
 
     await Future.wait(_liveTestsBySuite.map((suite) {
       return _pool.withResource(() {
         if (_closed) return null;
 
         // TODO(nweiz): Use a real for loop when issue 23394 is fixed.
         return Future.forEach(suite, (liveTest) async {
           // TODO(nweiz): Just "return;" when issue 23200 is fixed.
           if (_closed) return null;
+
+          _active.add(liveTest);
+
+          liveTest.onStateChange.listen((state) {
+            if (state.status != Status.complete) return;
+            _active.remove(liveTest);
+
+            if (state.result != Result.success) {
+              _passed.remove(liveTest);
+              _failed.add(liveTest);
+            } else if (liveTest.test.metadata.skip) {
+              _skipped.add(liveTest);
+            } else {
+              _passed.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 the DOM or other non-microtask events.
           await new Future.microtask(liveTest.run);
           await new Future(() {});
         });
       });
     }));
 
     return liveTests.every(
         (liveTest) => liveTest.state.result == Result.success);
   }
 
   /// 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.
   Future close() {
     _closed = true;
     return Future.wait(liveTests.map((liveTest) => liveTest.close()));
   }
 }