Print the full names of tests where possible.

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';
 
 /// 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
@@ skipping 55 matching lines @@
   /// 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;
 
   /// 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
@@ skipping 32 matching lines @@
       _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));
 
     liveTest.onError.listen((error) =>
         _onError(liveTest, error.error, error.stackTrace));
 
     liveTest.onPrint.listen((line) {
-      _progressLine(_description(liveTest));
+      _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('');
       print(indent('${_yellow}Skip: ${liveTest.test.metadata.skipReason}'
           '$_noColor'));
     } else {
       // Always display the name of the oldest active test, unless testing
       // is finished in which case display the last test to complete.
       if (_engine.active.isEmpty) {
         _progressLine(_description(liveTest));
       } else {
         _progressLine(_description(_engine.active.first));
       }
-
-      _printedNewline = false;
     }
   }
 
   /// A callback called when [liveTest] throws [error].
   void _onError(LiveTest liveTest, error, StackTrace stackTrace) {
     if (liveTest.state.status != Status.complete) return;
 
-    _progressLine(_description(liveTest));
+    _progressLine(_description(liveTest), truncate: false);
     if (!_printedNewline) print('');
     _printedNewline = true;
 
     if (error is! LoadException) {
       print(indent(error.toString()));
       var chain = terseChain(stackTrace, verbose: _verboseTrace);
       print(indent(chain.toString()));
       return;
     }
 
@@ skipping 45 matching lines @@
       _progressLine("All tests passed!");
       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}) {
+  bool _progressLine(String message, {String color, bool truncate: true}) {
     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) {
+        message == _lastProgressMessage &&
+        truncate == _lastProgressTruncated) {
       return false;
     }
 
     _lastProgressPassed = _engine.passed.length;
     _lastProgressSkipped = _engine.skipped.length;
     _lastProgressFailed = _engine.failed.length;
     _lastProgressElapsed = elapsed;
     _lastProgressMessage = message;
+    _lastProgressTruncated = truncate;
 
     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('+');
     buffer.write(_engine.passed.length);
@@ skipping 13 matching lines @@
       buffer.write(_noColor);
     }
 
     buffer.write(': ');
     buffer.write(color);
 
     // Ensure the line fits within [_lineLength]. [buffer] includes the color
     // escape sequences too. Because these sequences are not visible characters,
     // we make sure they are not counted towards the limit.
     var length = withoutColors(buffer.toString()).length;
-    buffer.write(truncate(message, _lineLength - length));
+    if (truncate) message = utils.truncate(message, _lineLength - length);
+    buffer.write(message);
     buffer.write(_noColor);
 
     // Pad the rest of the line so that it looks erased.
     buffer.write(' ' * (_lineLength - withoutColors(buffer.toString()).length));
     stdout.write(buffer.toString());
+
+    _printedNewline = false;
     return true;
   }
 
   /// Returns a representation of [duration] as `MM:SS`.
   String _timeString(Duration duration) {
     return "${duration.inMinutes.toString().padLeft(2, '0')}:"
         "${(duration.inSeconds % 60).toString().padLeft(2, '0')}";
   }
 
   /// Returns a description of [liveTest].
   ///
   /// This differs from the test's own description in that it may also include
   /// the suite's name.
   String _description(LiveTest liveTest) {
     var name = liveTest.test.name;
 
     if (_printPath && liveTest.suite.path != null) {
       name = "${liveTest.suite.path}: $name";
     }
 
     if (_printPlatform && liveTest.suite.platform != null) {
       name = "[${liveTest.suite.platform}] $name";
     }
 
     if (liveTest.suite is LoadSuite) name = "$_bold$_gray$name$_noColor";
 
     return name;
   }
 }