Add test- and group-level support for skipping tests.

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';
 
@@ skipping 16 matching lines @@
   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;
 
+  /// The terminal escape for yellow text, or the empty string if this is
+  /// Windows or not outputting to a terminal.
+  final String _yellow;
+
   /// The terminal escape for removing test coloring, or the empty string if
   /// this is Windows or not outputting to a terminal.
   final String _noColor;
 
   /// The engine used to run the tests.
   final Engine _engine;
 
   /// Whether multiple test files are being run.
   final bool _multiplePaths;
 
   /// Whether tests are being run on multiple platforms.
   final bool _multiplePlatforms;
 
   /// A stopwatch that tracks the duration of the full run.
   final _stopwatch = new Stopwatch();
 
   /// The set of tests that have completed and been marked as passing.
   final _passed = new Set<LiveTest>();
 
+  /// The set of tests that have completed and been marked as skipped.
+  final _skipped = new Set<LiveTest>();
+
   /// The set of tests that have completed and been marked as failing or error.
   final _failed = new Set<LiveTest>();
 
   /// The set of tests that are still running.
   final _active = new List<LiveTest>();
 
   /// Whether [close] has been called.
   bool _closed = false;
 
   /// The size of [_passed] last time a progress notification was printed.
   int _lastProgressPassed;
 
+  /// The size of [_skipped] last time a progress notification was printed.
+  int _lastProgressSkipped;
+
   /// The size of [_failed] last time a progress notification was printed.
   int _lastProgressFailed;
 
   /// The message printed for the last progress notification.
   String _lastProgressMessage;
 
   // Whether a newline has been printed since the last progress line.
   var _printedNewline = true;
 
   /// Creates a [ConsoleReporter] that will run all tests in [suites].
   ///
   /// If [color] is `true`, this will use terminal colors; if it's `false`, it
   /// won't.
   CompactReporter(Iterable<Suite> suites, {int concurrency, bool color: true})
       : _multiplePaths = suites.map((suite) => suite.path).toSet().length > 1,
         _multiplePlatforms =
             suites.map((suite) => suite.platform).toSet().length > 1,
         _engine = new Engine(suites, concurrency: concurrency),
         _color = color,
         _green = color ? '\u001b[32m' : '',
         _red = color ? '\u001b[31m' : '',
+        _yellow = color ? '\u001b[33m' : '',
         _noColor = color ? '\u001b[0m' : '' {
     _engine.onTestStarted.listen((liveTest) {
       if (_active.isEmpty) _progressLine(_description(liveTest));
       _active.add(liveTest);
       _printedNewline = false;
 
       liveTest.onStateChange.listen((state) {
         if (state.status != Status.complete) return;
         _active.remove(liveTest);
-        if (state.result == Result.success) {
-          _passed.add(liveTest);
-        } else {
+
+        if (state.result != Result.success) {
           _passed.remove(liveTest);
           _failed.add(liveTest);
+        } else if (liveTest.test.metadata.skip) {
+          _skipped.add(liveTest);
+        } else {
+          _passed.add(liveTest);
         }
 
         // Always display the name of the oldest active test, unless testing is
         // finished in which case display the last test to complete.
         if (_active.isEmpty) {
           _progressLine(_description(liveTest));
         } else {
           _progressLine(_description(_active.first));
         }
 
-        _printedNewline = false;
+        if (liveTest.test.metadata.skip &&
+            liveTest.test.metadata.skipReason != null) {
+          print('');
+          print(indent('${_yellow}Skip: ${liveTest.test.metadata.skipReason}'
+              '$_noColor'));
+        } else {
+          _printedNewline = false;
+        }
       });
 
       liveTest.onError.listen((error) {
         if (liveTest.state.status != Status.complete) return;
 
         _progressLine(_description(liveTest));
         if (!_printedNewline) print('');
         _printedNewline = true;
 
         if (error.error is! LoadException) {
@@ skipping 35 matching lines @@
 
     if (_engine.liveTests.isEmpty) {
       print("No tests ran.");
       return new Future.value(true);
     }
 
     _stopwatch.start();
     return _engine.run().then((success) {
       if (_closed) return false;
 
-      if (success) {
-        _progressLine("All tests passed!");
+      if (!success) {
+        _progressLine('Some tests failed.', color: _red);
+        print('');
+      } else if (_passed.isEmpty) {
+        _progressLine("All tests skipped.");
         print('');
       } else {
-        _progressLine('Some tests failed.', color: _red);
+        _progressLine("All tests passed!");
         print('');
       }
 
       return success;
     });
   }
 
   /// Signals that the caller is done with any test output and the reporter
   /// should release any resources it has allocated.
   Future close() {
     if (!_printedNewline) print("");
     _printedNewline = true;
     _closed = true;
     return _engine.close();
   }
 
   /// 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}) {
     // Print nothing if nothing has changed since the last progress line.
     if (_passed.length == _lastProgressPassed &&
+        _skipped.length == _lastProgressSkipped &&
         _failed.length == _lastProgressFailed &&
         message == _lastProgressMessage) {
       return false;
     }
 
     _lastProgressPassed = _passed.length;
+    _lastProgressSkipped = _skipped.length;
     _lastProgressFailed = _failed.length;
     _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('+');
     buffer.write(_passed.length);
     buffer.write(_noColor);
 
+    if (_skipped.isNotEmpty) {
+      buffer.write(_yellow);
+      buffer.write(' ~');
+      buffer.write(_skipped.length);
+      buffer.write(_noColor);
+    }
+
     if (_failed.isNotEmpty) {
       buffer.write(_red);
       buffer.write(' -');
       buffer.write(_failed.length);
       buffer.write(_noColor);
     }
 
     buffer.write(': ');
     buffer.write(color);
 
@@ skipping 30 matching lines @@
       name = "${liveTest.suite.path}: $name";
     }
 
     if (_multiplePlatforms && liveTest.suite.platform != null) {
       name = "[${liveTest.suite.platform}] $name";
     }
 
     return name;
   }
 }