Support re-running tests while 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;
@@ skipping 120 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 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 set of tests that have been marked for restarting.
+  ///
+  /// This is always a subset of [active]. Once a test in here has finished
+  /// running, it's run again.
+  final _restarted = 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 166 matching lines @@
     });
 
     _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);
     await new Future(() {});
+
+    if (!_restarted.contains(liveTest)) return;
+    await _runLiveTest(liveTest.copy(), countSuccess: countSuccess);
+    _restarted.remove(liveTest);
+  }
+
+  /// Closes [liveTest] and tells the engine to re-run it once it's done
+  /// running.
+  ///
+  /// Returns the same future as [LiveTest.close].
+  Future restartTest(LiveTest liveTest) async {
+    if (_activeLoadTests.contains(liveTest)) {
+      throw new ArgumentError("Can't restart a load test.");
+    }
+
+    if (!_active.contains(liveTest)) {
+      throw new StateError("Can't restart inactive test "
+          "\"${liveTest.test.name}\".");
+    }
+
+    _restarted.add(liveTest);
+    _active.remove(liveTest);
+    await liveTest.close();
   }
 
   /// Adds listeners for [suite].
   ///
   /// Load suites have specific logic apart from normal test suites.
   Future<RunnerSuite> _addLoadSuite(LoadSuite suite) async {
     var liveTest = await suite.test.load(suite);
 
     _activeLoadTests.add(liveTest);
 
@@ skipping 60 matching lines @@
     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);
   }
 }