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

lib/src/runner/reporter/compact.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.reporter.compact;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import '../../backend/live_test.dart';
 import '../../backend/state.dart';
 import '../../utils.dart';
 import '../../utils.dart' as utils;
 import '../engine.dart';
 import '../load_exception.dart';
 import '../load_suite.dart';
+import '../reporter.dart';
 
 /// The maximum console line length.
 ///
 /// Lines longer than this will be cropped.
 const _lineLength = 100;
 
 /// A reporter that prints test results to the console in a single
 /// continuously-updating line.
-class CompactReporter {
+class CompactReporter implements Reporter {
   /// Whether the reporter should emit terminal color escapes.
   final bool _color;
 
   /// The terminal escape for green text, or the empty string if this is Windows
   /// or not outputting to a terminal.
   final String _green;
 
   /// The terminal escape for red text, or the empty string if this is Windows
   /// or not outputting to a terminal.
   final String _red;
@@ skipping 22 matching lines @@
 
   /// Whether the path to each test's suite should be printed.
   final bool _printPath;
 
   /// Whether the platform each test is running on should be printed.
   final bool _printPlatform;
 
   /// A stopwatch that tracks the duration of the full run.
   final _stopwatch = new Stopwatch();
 
-  /// A timer that triggers printing updated time information.
-  Timer _timer;
+  /// Whether we've started [_stopwatch].
+  ///
+  /// We can't just use `_stopwatch.isRunning` because the stopwatch is stopped
+  /// when the reporter is paused.
+  var _stopwatchStarted = false;
 
   /// The size of `_engine.passed` last time a progress notification was
   /// printed.
   int _lastProgressPassed;
 
   /// The size of `_engine.skipped` last time a progress notification was printed.
   int _lastProgressSkipped;
 
   /// The size of `_engine.failed` last time a progress notification was
   /// printed.
   int _lastProgressFailed;
 
   /// The duration of the test run in seconds last time a progress notification
   /// was printed.
   int _lastProgressElapsed;
 
   /// The message printed for the last progress notification.
   String _lastProgressMessage;
 
   /// Whether the message printed for the last progress notification was
   /// truncated.
   bool _lastProgressTruncated;
 
   // Whether a newline has been printed since the last progress line.
   var _printedNewline = true;
 
+  /// Whether the reporter is paused.
+  var _paused = false;
+
+  /// The set of all subscriptions to various streams.
+  final _subscriptions = new Set<StreamSubscription>();
+
   /// Watches the tests run by [engine] and prints their results to the
   /// terminal.
   ///
   /// If [color] is `true`, this will use terminal colors; if it's `false`, it
   /// won't. If [verboseTrace] is `true`, this will print core library frames.
   /// If [printPath] is `true`, this will print the path name as part of the
   /// test description. Likewise, if [printPlatform] is `true`, this will print
   /// the platform as part of the test description.
-  static void watch(Engine engine, {bool color: true, bool verboseTrace: false,
-          bool printPath: true, bool printPlatform: true}) {
-    new CompactReporter._(
+  static CompactReporter watch(Engine engine, {bool color: true,
+      bool verboseTrace: false, bool printPath: true,
+      bool printPlatform: true}) {
+    return new CompactReporter._(
         engine,
         color: color,
         verboseTrace: verboseTrace,
         printPath: printPath,
         printPlatform: printPlatform);
   }
 
   CompactReporter._(this._engine, {bool color: true, bool verboseTrace: false,
           bool printPath: true, bool printPlatform: true})
       : _verboseTrace = verboseTrace,
         _printPath = printPath,
         _printPlatform = printPlatform,
         _color = color,
         _green = color ? '\u001b[32m' : '',
         _red = color ? '\u001b[31m' : '',
         _yellow = color ? '\u001b[33m' : '',
         _gray = color ? '\u001b[1;30m' : '',
         _bold = color ? '\u001b[1m' : '',
         _noColor = color ? '\u001b[0m' : '' {
-    _engine.onTestStarted.listen(_onTestStarted);
-    _engine.success.then(_onDone);
+    _subscriptions.add(_engine.onTestStarted.listen(_onTestStarted));
+
+    /// Convert the future to a stream so that the subscription can be paused or
+    /// canceled.
+    _subscriptions.add(_engine.success.asStream().listen(_onDone));
+  }
+
+  void pause() {
+    if (_paused) return;
+    _paused = true;
+
+    if (!_printedNewline) print('');
+    _printedNewline = true;
+    _stopwatch.stop();
+
+    for (var subscription in _subscriptions) {
+      subscription.pause();
+    }
+  }
+
+  void resume() {
+    if (!_paused) return;
+    _paused = false;
+
+    if (_stopwatchStarted) _stopwatch.start();
+
+    for (var subscription in _subscriptions) {
+      subscription.resume();
+    }
+  }
+
+  void cancel() {
+    for (var subscription in _subscriptions) {
+      subscription.cancel();
+    }
+    _subscriptions.clear();
   }
 
   /// A callback called when the engine begins running [liveTest].
   void _onTestStarted(LiveTest liveTest) {
-    if (_timer == null) {
+    if (!_stopwatchStarted) {
+      _stopwatchStarted = true;
       _stopwatch.start();
       /// Keep updating the time even when nothing else is happening.
-      _timer = new Timer.periodic(new Duration(seconds: 1),
-          (_) => _progressLine(_lastProgressMessage));
+      _subscriptions.add(new Stream.periodic(new Duration(seconds: 1))
+          .listen((_) => _progressLine(_lastProgressMessage)));
     }
 
     // If this is the first test to start, print a progress line so the user
     // knows what's running. It's possible that the active test may not be
     // [liveTest] because the engine doesn't always surface load tests.
     if (_engine.active.length == 1 && _engine.active.first == liveTest) {
       _progressLine(_description(liveTest));
     }
 
-    liveTest.onStateChange.listen((state) => _onStateChange(liveTest, state));
+    _subscriptions.add(liveTest.onStateChange
+        .listen((state) => _onStateChange(liveTest, state)));
 
-    liveTest.onError.listen((error) =>
-        _onError(liveTest, error.error, error.stackTrace));
+    _subscriptions.add(liveTest.onError.listen((error) =>
+        _onError(liveTest, error.error, error.stackTrace)));
 
-    liveTest.onPrint.listen((line) {
+    _subscriptions.add(liveTest.onPrint.listen((line) {
       _progressLine(_description(liveTest), truncate: false);
       if (!_printedNewline) print('');
       _printedNewline = true;
 
       print(line);
-    });
+    }));
   }
 
   /// A callback called when [liveTest]'s state becomes [state].
   void _onStateChange(LiveTest liveTest, State state) {
     if (state.status != Status.complete) return;
 
     if (liveTest.test.metadata.skip &&
         liveTest.test.metadata.skipReason != null) {
       _progressLine(_description(liveTest));
       print('');
@@ skipping 34 matching lines @@
         error.innerError is! String) {
       print(indent(terseChain(stackTrace).toString()));
     }
   }
 
   /// A callback called when the engine is finished running tests.
   ///
   /// [success] will be `true` if all tests passed, `false` if some tests
   /// failed, and `null` if the engine was closed prematurely.
   void _onDone(bool success) {
-    if (_timer != null) _timer.cancel();
-    _timer = null;
+    cancel();
     _stopwatch.stop();
 
     // A null success value indicates that the engine was closed before the
     // tests finished running, probably because of a signal from the user. We
     // shouldn't print summary information, we should just make sure the
     // terminal cursor is on its own line.
     if (success == null) {
       if (!_printedNewline) print("");
       _printedNewline = true;
       return;
@@ skipping 107 matching lines @@
 
     if (_printPlatform && liveTest.suite.platform != null) {
       name = "[${liveTest.suite.platform.name}] $name";
     }
 
     if (liveTest.suite is LoadSuite) name = "$_bold$_gray$name$_noColor";
 
     return name;
   }
 }