Split out a RunnerSuite class.

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.
 
 library test.runner.engine;
 
 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/live_test.dart';
 import '../backend/live_test_controller.dart';
 import '../backend/state.dart';
-import '../backend/suite.dart';
 import '../backend/test.dart';
 import 'load_suite.dart';
+import 'runner_suite.dart';
 
 /// An [Engine] manages a run that encompasses multiple test suites.
 ///
 /// Test suites are provided by passing them into [suiteSink]. Once all suites
 /// have been provided, the user should close [suiteSink] to indicate this.
 /// [run] won't terminate until [suiteSink] is closed. Suites will be run in the
 /// order they're provided to [suiteSink]. Tests within those suites will
 /// likewise be run in the order of [Suite.tests].
 ///
 /// The current status of every test is visible via [liveTests]. [onTestStarted]
@@ skipping 47 matching lines @@
   Future<bool> get success async {
     await _group.future;
     if (_closedBeforeDone) return null;
     return liveTests.every((liveTest) =>
         liveTest.state.result == Result.success);
   }
 
   /// A group of futures for each test suite.
   final _group = new FutureGroup();
 
-  /// A sink used to pass [Suite]s in to the engine to run.
+  /// 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.
   ///
   /// Suites added to the sink will be closed by the engine based on its
   /// internal logic.
-  Sink<Suite> get suiteSink => new DelegatingSink(_suiteController.sink);
-  final _suiteController = new StreamController<Suite>();
+  Sink<RunnerSuite> get suiteSink => new DelegatingSink(_suiteController.sink);
+  final _suiteController = new StreamController<RunnerSuite>();
 
   /// All the currently-known tests that have run, are running, or will run.
   ///
   /// These are [LiveTest]s, representing the in-progress state of each test.
   /// Tests that have not yet begun running are marked [Status.pending]; tests
   /// that have finished are marked [Status.complete].
   ///
   /// This is guaranteed to contain the same tests as the union of [passed],
   /// [skipped], [failed], and [active].
   ///
@@ skipping 51 matching lines @@
     }).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<Suite> suites, {int concurrency}) {
+  factory Engine.withSuites(List<RunnerSuite> suites, {int concurrency}) {
     var engine = new Engine(concurrency: concurrency);
     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
@@ skipping 68 matching lines @@
 
           loadResource.allowRelease(() => suite.close());
         });
       }));
     }, onDone: _group.close);
 
     return success;
   }
 
   /// Returns a dummy [LiveTest] for a test marked as "skip".
-  LiveTest _skippedTest(Suite suite, Test test) {
+  LiveTest _skippedTest(RunnerSuite suite, Test test) {
     var controller;
     controller = new LiveTestController(suite, test, () {
       controller.setState(const State(Status.running, Result.success));
       controller.setState(const State(Status.complete, Result.success));
       controller.completer.complete();
     }, () {});
     return controller.liveTest;
   }
 
   /// Adds listeners for [suite].
   ///
   /// Load suites have specific logic apart from normal test suites.
-  Future<Suite> _addLoadSuite(LoadSuite suite) async {
+  Future<RunnerSuite> _addLoadSuite(LoadSuite suite) async {
     var liveTest = await suite.tests.single.load(suite);
 
     _activeLoadTests.add(liveTest);
 
     // Only surface the load test if there are no other tests currently running.
     if (_active.isEmpty) {
       _liveTests.add(liveTest);
       _active.add(liveTest);
     }
 
@@ skipping 45 matching lines @@
 
     // Close the running tests first so that we're sure to wait for them to
     // finish before we close their suites and cause them to become unloaded.
     var allLiveTests = liveTests.toSet()..addAll(_activeLoadTests);
     await Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
 
     var allSuites = allLiveTests.map((liveTest) => liveTest.suite).toSet();
     await Future.wait(allSuites.map((suite) => suite.close()));
   }
 }