Add an option to run skipped tests.

lib/src/runner/engine.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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async/async.dart' hide Result;
 import 'package:collection/collection.dart';
 import 'package:pool/pool.dart';
 
 import '../backend/group.dart';
-import '../backend/group_entry.dart';
 import '../backend/invoker.dart';
 import '../backend/live_test.dart';
 import '../backend/live_test_controller.dart';
 import '../backend/message.dart';
 import '../backend/state.dart';
 import '../backend/test.dart';
 import '../util/iterable_set.dart';
 import 'live_suite.dart';
 import 'live_suite_controller.dart';
 import 'load_suite.dart';
@@ skipping 21 matching lines @@
 /// and [liveTests]. If this test passes, it will be removed from both [active]
 /// and [liveTests] and *will not* be added to [passed]. If at any point a load
 /// test fails, it will be added to [failed] and [liveTests].
 ///
 /// The test suite loaded by a load suite will be automatically be run by the
 /// engine; it doesn't need to be added to [suiteSink] manually.
 ///
 /// Load tests will always be emitted through [onTestStarted] so users can watch
 /// their event streams once they start running.
 class Engine {
+  /// Whether to run skipped tests.
+  final bool _runSkipped;
+
   /// Whether [run] has been called yet.
   var _runCalled = false;
 
   /// Whether [close] has been called.
   var _closed = false;
 
   /// Whether [close] was called before all the tests finished running.
   ///
   /// This is `null` if close hasn't been called and the tests are still
   /// running, `true` if close was called before the tests finished running, and
@@ skipping 117 matching lines @@
   /// This is separate from [active] because load tests aren't always surfaced.
   final _activeLoadTests = new List<LiveTest>();
 
   /// Whether this engine is idle—that is, not currently executing a test.
   bool get isIdle => _group.isIdle;
 
   /// A broadcast stream that fires an event whenever [isIdle] switches from
   /// `false` to `true`.
   Stream get onIdle => _group.onIdle;
 
+  // TODO(nweiz): Use interface libraries to take a Configuration even when
+  // dart:io is unavailable.
   /// Creates an [Engine] that will run all tests provided via [suiteSink].
   ///
   /// [concurrency] controls how many suites are run at once, and defaults to 1.
   /// [maxSuites] controls how many suites are *loaded* at once, and defaults to
-  /// four times [concurrency].
-  Engine({int concurrency, int maxSuites})
-      : _runPool = new Pool(concurrency == null ? 1 : concurrency),
-        _loadPool = new Pool(maxSuites == null
-            ? (concurrency == null ? 2 : concurrency * 2)
-            : maxSuites) {
+  /// four times [concurrency]. If [runSkipped] is `true`, skipped tests will be
+  /// run as though they weren't skipped.
+  Engine({int concurrency, int maxSuites, bool runSkipped: false})
+      : _runPool = new Pool(concurrency ?? 1),
+        _loadPool = new Pool(maxSuites ?? (concurrency ?? 1) * 2),
+        _runSkipped = runSkipped {
     _group.future.then((_) {
       _onTestStartedGroup.close();
       _onSuiteStartedController.close();
       if (_closedBeforeDone == null) _closedBeforeDone = false;
     }).catchError((_) {
       // Don't top-level errors. They'll be thrown via [success] anyway.
     });
   }
 
   /// Creates an [Engine] that will run all tests in [suites].
   ///
-  /// [concurrency] controls how many suites are run at once. An engine
-  /// constructed this way will automatically close its [suiteSink], meaning
-  /// that no further suites may be provided.
-  factory Engine.withSuites(List<RunnerSuite> suites, {int concurrency}) {
-    var engine = new Engine(concurrency: concurrency);
+  /// An engine constructed this way will automatically close its [suiteSink],
+  /// meaning that no further suites may be provided.
+  ///
+  /// [concurrency] controls how many suites are run at once. If [runSkipped] is
+  /// `true`, skipped tests will be run as though they weren't skipped.
+  factory Engine.withSuites(List<RunnerSuite> suites, {int concurrency,
+      bool runSkipped: false}) {
+    var engine = new Engine(concurrency: concurrency, runSkipped: runSkipped);
     for (var suite in suites) engine.suiteSink.add(suite);
     engine.suiteSink.close();
     return engine;
   }
 
   /// Runs all tests in all suites defined by this engine.
   ///
   /// This returns `true` if all tests succeed, and `false` otherwise. It will
   /// only return once all tests have finished running and [suiteSink] has been
   /// closed.
@@ skipping 41 matching lines @@
   /// Runs all the entries in [group] in sequence.
   ///
   /// [suiteController] is the controller fo the suite that contains [group].
   /// [parents] is a list of groups that contain [group]. It may be modified,
   /// but it's guaranteed to be in its original state once this function has
   /// finished.
   Future _runGroup(LiveSuiteController suiteController, Group group,
       List<Group> parents) async {
     parents.add(group);
     try {
-      if (group.metadata.skip) {
-        await _runSkippedTest(suiteController, group, parents);
-        return;
-      }
-
+      var skipGroup = !_runSkipped && group.metadata.skip;
       var setUpAllSucceeded = true;
-      if (group.setUpAll != null) {
+      if (!skipGroup && group.setUpAll != null) {
         var liveTest = group.setUpAll.load(suiteController.liveSuite.suite,
             groups: parents);
         await _runLiveTest(suiteController, liveTest, countSuccess: false);
         setUpAllSucceeded = liveTest.state.result.isPassing;
       }
 
       if (!_closed && setUpAllSucceeded) {
         for (var entry in group.entries) {
           if (_closed) return;
 
           if (entry is Group) {
             await _runGroup(suiteController, entry, parents);
-          } else if (entry.metadata.skip) {
+          } else if (!_runSkipped && entry.metadata.skip) {
             await _runSkippedTest(suiteController, entry, parents);
           } else {
             var test = entry as Test;
             await _runLiveTest(
                 suiteController,
                 test.load(suiteController.liveSuite.suite, groups: parents));
           }
         }
       }
 
       // Even if we're closed or setUpAll failed, we want to run all the
       // teardowns to ensure that any state is properly cleaned up.
-      if (group.tearDownAll != null) {
+      if (!skipGroup && group.tearDownAll != null) {
         var liveTest = group.tearDownAll.load(suiteController.liveSuite.suite,
             groups: parents);
         await _runLiveTest(suiteController, liveTest, countSuccess: false);
         if (_closed) await liveTest.close();
       }
     } finally {
       parents.remove(group);
     }
   }
 
@@ skipping 29 matching lines @@
     // Once the test finishes, use [new Future] to do a coarse-grained event
     // loop pump to avoid starving non-microtask events.
     await new Future(() {});
 
     if (!_restarted.contains(liveTest)) return;
     await _runLiveTest(suiteController, liveTest.copy(),
         countSuccess: countSuccess);
     _restarted.remove(liveTest);
   }
 
-  /// Runs a dummy [LiveTest] for a test or group marked as "skip".
+  /// Runs a dummy [LiveTest] for a test marked as "skip".
   ///
-  /// [suiteController] is the controller for the suite that contains [entry].
-  /// [parents] is a list of groups that contain [entry].
-  Future _runSkippedTest(LiveSuiteController suiteController, GroupEntry entry,
+  /// [suiteController] is the controller for the suite that contains [test].
+  /// [parents] is a list of groups that contain [test].
+  Future _runSkippedTest(LiveSuiteController suiteController, Test test,
       List<Group> parents) {
-    // The netry name will be `null` for the root group.
-    var test = new LocalTest(entry.name ?? "(suite)", entry.metadata, () {},
-        trace: entry.trace);
+    var skipped = new LocalTest(test.name, test.metadata, () {},
+        trace: test.trace);
 
     var controller;
     controller = new LiveTestController(
-        suiteController.liveSuite.suite, test, () {
+        suiteController.liveSuite.suite, skipped, () {
       controller.setState(const State(Status.running, Result.success));
       controller.setState(const State(Status.running, Result.skipped));
 
-      if (entry.metadata.skipReason != null) {
+      if (skipped.metadata.skipReason != null) {
         controller.message(
-            new Message.skip("Skip: ${entry.metadata.skipReason}"));
+            new Message.skip("Skip: ${skipped.metadata.skipReason}"));
       }
 
       controller.setState(const State(Status.complete, Result.skipped));
       controller.completer.complete();
     }, () {}, groups: parents);
 
     return _runLiveTest(suiteController, controller.liveTest);
   }
 
   /// Closes [liveTest] and tells the engine to re-run it once it's done
@@ skipping 98 matching lines @@
     var futures = allLiveTests.map((liveTest) => liveTest.close()).toList();
 
     // Closing the load pool will close the test suites as soon as their tests
     // are done. For browser suites this is effectively immediate since their
     // tests shut down as soon as they're closed, but for VM suites we may need
     // to wait for tearDowns or tearDownAlls to run.
     futures.add(_loadPool.close());
     await Future.wait(futures, eagerError: true);
   }
 }