Add a dedicated Result for 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';
@@ skipping 55 matching lines @@
 
   /// A pool that limits the number of test suites running concurrently.
   final Pool _runPool;
 
   /// A pool that limits the number of test suites loaded concurrently.
   ///
   /// Once this reaches its limit, loading any additional test suites will cause
   /// previous suites to be unloaded in the order they completed.
   final Pool _loadPool;
 
-  /// Whether all tests passed.
+  /// Whether all tests passed or were skipped.
   ///
   /// This fires once all tests have completed and [suiteSink] has been closed.
   /// This will be `null` if [close] was called before all the tests finished
   /// running.
   Future<bool> get success async {
     await _group.future;
     if (_closedBeforeDone) return null;
-    return liveTests.every((liveTest) =>
-        liveTest.state.result == Result.success);
+    return liveTests.every((liveTest) => liveTest.state.result.isPassing);
   }
 
   /// A group of futures for each test suite.
   final _group = new FutureGroup();
 
   /// A sink used to pass [RunnerSuite]s in to the engine to run.
   ///
   /// Suites may be added as quickly as they're available; the Engine will only
   /// run as many as necessary at a time based on its concurrency settings.
   ///
@@ skipping 183 matching lines @@
       if (group.metadata.skip) {
         await _runSkippedTest(suiteController, group, parents);
         return;
       }
 
       var setUpAllSucceeded = true;
       if (group.setUpAll != null) {
         var liveTest = group.setUpAll.load(suiteController.liveSuite.suite,
             groups: parents);
         await _runLiveTest(suiteController, liveTest, countSuccess: false);
-        setUpAllSucceeded = liveTest.state.result == Result.success;
+        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) {
             await _runSkippedTest(suiteController, entry, parents);
@@ skipping 65 matching lines @@
   Future _runSkippedTest(LiveSuiteController suiteController, GroupEntry entry,
       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 controller;
     controller = new LiveTestController(
         suiteController.liveSuite.suite, test, () {
       controller.setState(const State(Status.running, Result.success));
-      controller.setState(const State(Status.complete, Result.success));
+      controller.setState(const State(Status.running, Result.skipped));
+      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
   /// running.
   ///
   /// Returns the same future as [LiveTest.close].
@@ skipping 95 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);
   }
 }