Add a --pause-after-load flag for debugging.

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;
 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 '../util/delegating_sink.dart';
 import 'load_suite.dart';
 
 /// An [Engine] manages a run that encompasses multiple test suites.
 ///
 /// Test suites are provided by passing them into [suiteSink]. Once all suites
 /// have been provided, the user should close [suiteSink] to indicate this.
 /// [run] won't terminate until [suiteSink] is closed. Suites will be run in the
 /// order they're provided to [suiteSink]. Tests within those suites will
 /// likewise be run in the order of [Suite.tests].
 ///
@@ skipping 99 matching lines @@
   /// 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 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
+  /// `false` to `true`.
+  Stream get onIdle => _group.onIdle;
+
   /// Creates an [Engine] that will run all tests provided via [suiteSink].
   ///
   /// [concurrency] controls how many suites are run at once, and defaults to 1.
   /// [maxSuites] controls how many suites are *loaded* at once, and defaults to
   /// four times [concurrency].
   Engine({int concurrency, int maxSuites})
       : _runPool = new Pool(concurrency == null ? 1 : concurrency),
         _loadPool = new Pool(maxSuites == null
             ? (concurrency == null ? 2 : concurrency * 2)
             : maxSuites) {
@@ skipping 170 matching lines @@
 
     // 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);
     await Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
 
     var allSuites = allLiveTests.map((liveTest) => liveTest.suite).toSet();
     await Future.wait(allSuites.map((suite) => suite.close()));
   }
 }