Only load a certain number of test suites at once.

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;
@@ skipping 24 matching lines @@
 /// into the process of loading test files, but as long as that process is
 /// proceeding normally users usually don't care about it, so the engine only
 /// surfaces running load tests (that is, includes them in [liveTests] and other
 /// collections) under specific circumstances.
 ///
 /// If only load tests are running, exactly one load test will be in [active]
 /// 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 [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
   /// `false` if the tests finished running before close was called.
   var _closedBeforeDone;
 
   /// A pool that limits the number of test suites running concurrently.
-  final Pool _pool;
+  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.
   ///
   /// 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);
   }
 
   /// 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.
   ///
   /// 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>();
 
   /// 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],
@@ skipping 26 matching lines @@
   final _active = new QueueList<LiveTest>();
 
   /// The tests from [LoadSuite]s that are still running, in the order they
   /// began running.
   ///
   /// This is separate from [active] because load tests aren't always surfaced.
   final _activeLoadTests = new List<LiveTest>();
 
   /// Creates an [Engine] that will run all tests provided via [suiteSink].
   ///
-  /// [concurrency] controls how many suites are run at once.
-  Engine({int concurrency})
-      : _pool = new Pool(concurrency == null ? 1 : concurrency) {
+  /// [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 ? 4 : concurrency * 4)
+            : maxSuites) {
     _group.future.then((_) {
       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
@@ skipping 11 matching lines @@
   /// 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.
   Future<bool> run() {
     if (_runCalled) {
       throw new StateError("Engine.run() may not be called more than once.");
     }
     _runCalled = true;
 
     _suiteController.stream.listen((suite) {
-      if (suite is LoadSuite) {
-        _group.add(_addLoadSuite(suite));
-        return;
-      }
+      _group.add(new Future.sync(() async {
+        var loadResource = await _loadPool.request();
 
-      _group.add(_pool.withResource(() {
-        if (_closed) return null;
+        if (suite is LoadSuite) {
+          suite = await _addLoadSuite(suite);
+          if (suite == null) {
+            loadResource.release();
+            return;
+          }
+        }
 
-        // TODO(nweiz): Use a real for loop when issue 23394 is fixed.
-        return Future.forEach(suite.tests, (test) async {
-          if (_closed) return;
+        await _runPool.withResource(() async {
+          if (_closed) return null;
 
-          var liveTest = test.metadata.skip
-              ? _skippedTest(suite, test)
-              : test.load(suite);
-          _liveTests.add(liveTest);
-          _active.add(liveTest);
+          // TODO(nweiz): Use a real for loop when issue 23394 is fixed.
+          await Future.forEach(suite.tests, (test) async {
+            if (_closed) return;
 
-          // If there were no active non-load tests, the current active test
-          // would have been a load test. In that case, remove it, since now we
-          // have a non-load test to add.
-          if (_active.isNotEmpty && _active.first.suite is LoadSuite) {
-            _liveTests.remove(_active.removeFirst());
-          }
+            var liveTest = test.metadata.skip
+                ? _skippedTest(suite, test)
+                : test.load(suite);
+            _liveTests.add(liveTest);
+            _active.add(liveTest);
 
-          liveTest.onStateChange.listen((state) {
-            if (state.status != Status.complete) return;
-            _active.remove(liveTest);
-
-            // If we're out of non-load tests, surface a load test.
-            if (_active.isEmpty && _activeLoadTests.isNotEmpty) {
-              _active.add(_activeLoadTests.first);
-              _liveTests.add(_activeLoadTests.first);
+            // If there were no active non-load tests, the current active test
+            // would have been a load test. In that case, remove it, since now we
+            // have a non-load test to add.
+            if (_active.isNotEmpty && _active.first.suite is LoadSuite) {
+              _liveTests.remove(_active.removeFirst());
             }
 
-            if (state.result != Result.success) {
-              _passed.remove(liveTest);
-              _failed.add(liveTest);
-            } else if (liveTest.test.metadata.skip) {
-              _skipped.add(liveTest);
-            } else {
-              _passed.add(liveTest);
-            }
+            liveTest.onStateChange.listen((state) {
+              if (state.status != Status.complete) return;
+              _active.remove(liveTest);
+
+              // If we're out of non-load tests, surface a load test.
+              if (_active.isEmpty && _activeLoadTests.isNotEmpty) {
+                _active.add(_activeLoadTests.first);
+                _liveTests.add(_activeLoadTests.first);
+              }
+
+              if (state.result != Result.success) {
+                _passed.remove(liveTest);
+                _failed.add(liveTest);
+              } else if (liveTest.test.metadata.skip) {
+                _skipped.add(liveTest);
+              } else {
+                _passed.add(liveTest);
+              }
+            });
+
+            _onTestStartedController.add(liveTest);
+
+            // First, schedule a microtask to ensure that [onTestStarted] fires
+            // before the first [LiveTest.onStateChange] event. Once the test
+            // finishes, use [new Future] to do a coarse-grained event loop pump
+            // to avoid starving non-microtask events.
+            await new Future.microtask(liveTest.run);
+            await new Future(() {});
           });
 
-          _onTestStartedController.add(liveTest);
-
-          // First, schedule a microtask to ensure that [onTestStarted] fires
-          // before the first [LiveTest.onStateChange] event. Once the test
-          // finishes, use [new Future] to do a coarse-grained event loop pump
-          // to avoid starving non-microtask events.
-          await new Future.microtask(liveTest.run);
-          await new Future(() {});
+          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) {
     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 _addLoadSuite(LoadSuite suite) async {
+  Future<Suite> _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 17 matching lines @@
       // Surface the load test if it fails so that the user can see the failure.
       if (state.result == Result.success) return;
       _failed.add(liveTest);
       _liveTests.add(liveTest);
     });
 
     // Run the test immediately. We don't want loading to be blocked on suites
     // that are already running.
     _onTestStartedController.add(liveTest);
     await liveTest.run();
+
+    return suite.suite;
   }
 
   /// Signals that the caller is done paying attention to test results and the
   /// engine should release any resources it has allocated.
   ///
   /// Any actively-running tests are also closed. VM tests are allowed to finish
   /// running so that any modifications they've made to the filesystem can be
   /// cleaned up.
   ///
   /// **Note that closing the engine is not the same as closing [suiteSink].**
   /// Closing [suiteSink] indicates that no more input will be provided, closing
   /// the engine indicates that no more output should be emitted.
-  Future close() {
+  Future close() async {
     _closed = true;
     if (_closedBeforeDone == null) _closedBeforeDone = true;
     _suiteController.close();
 
+    // 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);
-    return Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
+    await Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
+
+    var allSuites = allLiveTests.map((liveTest) => liveTest.suite).toSet();
+    await Future.wait(allSuites.map((suite) => suite.close()));
   }
 }