Continuously update the compact reporter's clock.

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 '../engine.dart';
 import '../load_exception.dart';
 import '../load_suite.dart';
 
@@ skipping 40 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;
+
   /// 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 a newline has been printed since the last progress line.
   var _printedNewline = true;
 
   /// 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
@@ skipping 22 matching lines @@
         _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);
   }
 
   /// A callback called when the engine begins running [liveTest].
   void _onTestStarted(LiveTest liveTest) {
-    if (!_stopwatch.isRunning) _stopwatch.start();
+    if (_timer == null) {
+      _stopwatch.start();
+      /// Keep updating the time even when nothing else is happening.
+      _timer = new Timer.periodic(new Duration(seconds: 1),
+          (_) => _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));
     }
     _printedNewline = false;
 
     liveTest.onStateChange.listen((state) => _onStateChange(liveTest, state));
@@ skipping 57 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) {
+    _timer.cancel();
+    _timer = null;
+    _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 16 matching lines @@
       print('');
     }
   }
 
   /// Prints a line representing the current state of the tests.
   ///
   /// [message] goes after the progress report, and may be truncated to fit the
   /// entire line within [_lineLength]. If [color] is passed, it's used as the
   /// color for [message].
   bool _progressLine(String message, {String color}) {
+    var elapsed = _stopwatch.elapsed.inSeconds;
+
     // Print nothing if nothing has changed since the last progress line.
     if (_engine.passed.length == _lastProgressPassed &&
         _engine.skipped.length == _lastProgressSkipped &&
         _engine.failed.length == _lastProgressFailed &&
+        elapsed == _lastProgressElapsed &&
         message == _lastProgressMessage) {
       return false;
     }
 
     _lastProgressPassed = _engine.passed.length;
     _lastProgressSkipped = _engine.skipped.length;
     _lastProgressFailed = _engine.failed.length;
+    _lastProgressElapsed = elapsed;
     _lastProgressMessage = message;
 
     if (color == null) color = '';
     var duration = _stopwatch.elapsed;
     var buffer = new StringBuffer();
 
     // \r moves back to the beginning of the current line.
     buffer.write('\r${_timeString(duration)} ');
     buffer.write(_green);
     buffer.write('+');
@@ skipping 49 matching lines @@
 
     if (_printPlatform && liveTest.suite.platform != null) {
       name = "[${liveTest.suite.platform}] $name";
     }
 
     if (liveTest.suite is LoadSuite) name = "$_bold$_gray$name$_noColor";
 
     return name;
   }
 }