Support re-running tests while debugging.

lib/src/runner.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;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:async/async.dart';
 
 import 'backend/group.dart';
 import 'backend/group_entry.dart';
 import 'backend/suite.dart';
 import 'backend/test.dart';
 import 'backend/test_platform.dart';
 import 'runner/application_exception.dart';
 import 'runner/configuration.dart';
+import 'runner/debugger.dart';
 import 'runner/engine.dart';
 import 'runner/load_exception.dart';
 import 'runner/load_suite.dart';
 import 'runner/loader.dart';
 import 'runner/reporter.dart';
 import 'runner/reporter/compact.dart';
 import 'runner/reporter/expanded.dart';
 import 'runner/reporter/json.dart';
-import 'runner/runner_suite.dart';
 import 'util/io.dart';
 import 'utils.dart';
 
 /// A class that loads and runs tests based on a [Configuration].
 ///
 /// This maintains a [Loader] and an [Engine] and passes test suites from one to
 /// the other, as well as printing out tests with a [CompactReporter] or an
 /// [ExpandedReporter].
 class Runner {
   /// The configuration for the runner.
@@ skipping 11 matching lines @@
   /// The subscription to the stream returned by [_loadSuites].
   StreamSubscription _suiteSubscription;
 
   /// The set of suite paths for which [_warnForUnknownTags] has already been
   /// called.
   ///
   /// This is used to avoid printing duplicate warnings when a suite is loaded
   /// on multiple platforms.
   final _tagWarningSuites = new Set<String>();
 
+  /// The current debug operation, if any.
+  ///
+  /// This is stored so that we can cancel it when the runner is closed.
+  CancelableOperation _debugOperation;
+
   /// The memoizer for ensuring [close] only runs once.
   final _closeMemo = new AsyncMemoizer();
   bool get _closed => _closeMemo.hasRun;
 
   /// Creates a new runner based on [configuration].
   factory Runner(Configuration config) {
     var loader = new Loader(config);
     var engine = new Engine(concurrency: config.concurrency);
 
     var reporter;
@@ skipping 80 matching lines @@
       timer = new Timer(new Duration(seconds: 1), () {
         // Pause the reporter while we print to ensure that we don't interfere
         // with its output.
         _reporter.pause();
         print("Waiting for current test(s) to finish.");
         print("Press Control-C again to terminate immediately.");
         _reporter.resume();
       });
     }
 
+    if (_debugOperation != null) await _debugOperation.cancel();
+
     if (_suiteSubscription != null) _suiteSubscription.cancel();
     _suiteSubscription = null;
 
     // Make sure we close the engine *before* the loader. Otherwise,
     // LoadSuites provided by the loader may get into bad states.
     await _engine.close();
     if (timer != null) timer.cancel();
     await _loader.close();
   });
 
@@ skipping 114 matching lines @@
 
   /// Loads each suite in [suites] in order, pausing after load for platforms
   /// that support debugging.
   Future<bool> _loadThenPause(Stream<LoadSuite> suites) async {
     if (_config.platforms.contains(TestPlatform.vm)) {
       warn("Debugging is currently unsupported on the Dart VM.",
           color: _config.color);
     }
 
     _suiteSubscription = suites.asyncMap((loadSuite) async {
-      // Make the underlying suite null so that the engine doesn't start running
-      // it immediately.
-      _engine.suiteSink.add(loadSuite.changeSuite((_) => null));
-
-      var suite = await loadSuite.suite;
-      if (suite == null) return;
-
-      await _pause(suite);
-      if (_closed) return;
-
-      _engine.suiteSink.add(suite);
-      await _engine.onIdle.first;
+      _debugOperation = debug(_config, _engine, _reporter, loadSuite);
+      await _debugOperation.valueOrCancellation();
     }).listen(null);
 
     var results = await Future.wait([
       _suiteSubscription.asFuture().then((_) => _engine.suiteSink.close()),
       _engine.run()
     ]);
     return results.last;
   }
-
-  /// Pauses the engine and the reporter so that the user can set breakpoints as
-  /// necessary.
-  ///
-  /// This is a no-op for test suites that aren't on platforms where debugging
-  /// is supported.
-  Future _pause(RunnerSuite suite) async {
-    if (suite.platform == null) return;
-    if (suite.platform == TestPlatform.vm) return;
-
-    try {
-      _reporter.pause();
-
-      var bold = _config.color ? '\u001b[1m' : '';
-      var yellow = _config.color ? '\u001b[33m' : '';
-      var noColor = _config.color ? '\u001b[0m' : '';
-      print('');
-
-      if (suite.platform.isDartVM) {
-        var url = suite.environment.observatoryUrl;
-        if (url == null) {
-          print("${yellow}Observatory URL not found. Make sure you're using "
-              "${suite.platform.name} 1.11 or later.$noColor");
-        } else {
-          print("Observatory URL: $bold$url$noColor");
-        }
-      }
-
-      if (suite.platform.isHeadless) {
-        var url = suite.environment.remoteDebuggerUrl;
-        if (url == null) {
-          print("${yellow}Remote debugger URL not found.$noColor");
-        } else {
-          print("Remote debugger URL: $bold$url$noColor");
-        }
-      }
-
-      var buffer = new StringBuffer(
-          "${bold}The test runner is paused.${noColor} ");
-      if (!suite.platform.isHeadless) {
-        buffer.write("Open the dev console in ${suite.platform} ");
-      } else {
-        buffer.write("Open the remote debugger ");
-      }
-      if (suite.platform.isDartVM) buffer.write("or the Observatory ");
-
-      buffer.write("and set breakpoints. Once you're finished, return to this "
-          "terminal and press Enter.");
-
-      print(wordWrap(buffer.toString()));
-
-      await inCompletionOrder([
-        suite.environment.displayPause(),
-        cancelableNext(stdinLines)
-      ]).first;
-    } finally {
-      _reporter.resume();
-    }
-  }
 }