Expand the JSON reporter to enable a progress bar.

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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async/async.dart' hide Result;
 import 'package:collection/collection.dart';
 import 'package:pool/pool.dart';
@@ skipping 77 matching lines @@
   /// A sink used to pass [RunnerSuite]s in to the engine to run.
   ///
   /// Suites may be added as quickly as they're available; the Engine will only
   /// run as many as necessary at a time based on its concurrency settings.
   ///
   /// Suites added to the sink will be closed by the engine based on its
   /// internal logic.
   Sink<RunnerSuite> get suiteSink => new DelegatingSink(_suiteController.sink);
   final _suiteController = new StreamController<RunnerSuite>();
 
+  /// All the [RunnerSuite]s added to [suiteSink] so far.
+  ///
+  /// Note that if a [LoadSuite] is added, this will only contain that suite,
+  /// not the suite it loads.
+  Set<RunnerSuite> get addedSuites => new UnmodifiableSetView(_addedSuites);
+  final _addedSuites = new Set<RunnerSuite>();
+
+  /// A broadcast that emits each [RunnerSuite] as it's added to the engine via
+  /// [suiteSink].
+  ///
+  /// Note that if a [LoadSuite] is added, this will only return that suite, not
+  /// the suite it loads.
+  ///
+  /// This is guaranteed to fire after the suite is added to [addedSuites].
+  Stream<RunnerSuite> get onSuiteAdded => _onSuiteAddedController.stream;
+  final _onSuiteAddedController = new StreamController<RunnerSuite>.broadcast();
+
   /// All the currently-known tests that have run, are running, or will run.
   ///
   /// These are [LiveTest]s, representing the in-progress state of each test.
   /// Tests that have not yet begun running are marked [Status.pending]; tests
   /// that have finished are marked [Status.complete].
   ///
   /// This is guaranteed to contain the same tests as the union of [passed],
   /// [skipped], [failed], and [active].
   ///
   /// [LiveTest.run] must not be called on these tests.
@@ skipping 81 matching lines @@
   /// This returns `true` if all tests succeed, and `false` otherwise. It will
   /// only return once all tests have finished running and [suiteSink] has been
   /// closed.
   Future<bool> run() {
     if (_runCalled) {
       throw new StateError("Engine.run() may not be called more than once.");
     }
     _runCalled = true;
 
     _suiteController.stream.listen((suite) {
+      _addedSuites.add(suite);
+      _onSuiteAddedController.add(suite);
+
       _group.add(new Future.sync(() async {
         var loadResource = await _loadPool.request();
 
         if (suite is LoadSuite) {
           suite = await _addLoadSuite(suite);
           if (suite == null) {
             loadResource.release();
             return;
           }
         }
 
         await _runPool.withResource(() async {
           if (_closed) return;
           await _runGroup(suite, suite.group, []);
           loadResource.allowRelease(() => suite.close());
         });
       }));
-    }, onDone: _group.close);
+    }, onDone: () {
+      _onSuiteAddedController.close();
+      _group.close();
+    });
 
     return success;
   }
 
   /// Runs all the entries in [entries] in sequence.
   ///
   /// [parents] is a list of groups that contain [group]. It may be modified,
   /// but it's guaranteed to be in its original state once this function has
   /// finished.
   Future _runGroup(RunnerSuite suite, Group group, List<Group> parents) async {
@@ skipping 180 matching lines @@
   /// 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;
+    _onSuiteAddedController.close();
     _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)
       ..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);
   }
 }