Only load a certain number of test suites at once.

lib/src/runner/loader.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.loader;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:path/path.dart' as p;
 import 'package:stack_trace/stack_trace.dart';
 
 import '../backend/invoker.dart';
 import '../backend/metadata.dart';
 import '../backend/suite.dart';
 import '../backend/test_platform.dart';
 import '../util/async_thunk.dart';
 import '../util/dart.dart' as dart;
 import '../util/io.dart';
-import '../util/isolate_wrapper.dart';
 import '../util/remote_exception.dart';
 import '../utils.dart';
 import 'browser/server.dart';
 import 'load_exception.dart';
 import 'load_suite.dart';
 import 'parse_metadata.dart';
 import 'vm/isolate_test.dart';
 
 /// A class for finding test files and loading them into a runnable form.
 class Loader {
@@ skipping 14 matching lines @@
   final String _root;
 
   /// The package root to use for loading tests.
   final String _packageRoot;
 
   /// The URL for the `pub serve` instance to use to load tests.
   ///
   /// This is `null` if tests should be loaded from the filesystem.
   final Uri _pubServeUrl;
 
-  /// All isolates that have been spun up by the loader.
-  final _isolates = new Set<IsolateWrapper>();
+  /// All suites that have been created by the loader.
+  final _suites = new Set<Suite>();
 
   /// The server that serves browser test pages.
   ///
   /// This is lazily initialized the first time it's accessed.
   Future<BrowserServer> get _browserServer {
     return _browserServerThunk.run(() {
       return BrowserServer.start(
           root: _root,
           packageRoot: _packageRoot,
           pubServeUrl: _pubServeUrl,
@@ skipping 164 matching lines @@
           'reply': receivePort.sendPort,
           'metadata': metadata.serialize()
         }, packageRoot: p.toUri(_packageRoot), checked: true);
       }
     } catch (error, stackTrace) {
       receivePort.close();
       if (error is LoadException) rethrow;
       await new Future.error(new LoadException(path, error), stackTrace);
     }
 
-    _isolates.add(isolate);
-
     var completer = new Completer();
 
     var subscription = receivePort.listen((response) {
       if (response["type"] == "print") {
         print(response["line"]);
       } else if (response["type"] == "loadException") {
+        isolate.kill();
         completer.completeError(
             new LoadException(path, response["message"]),
             new Trace.current());
       } else if (response["type"] == "error") {
+        isolate.kill();
         var asyncError = RemoteException.deserialize(response["error"]);
         completer.completeError(
             new LoadException(path, asyncError.error),
             asyncError.stackTrace);
       } else {
         assert(response["type"] == "success");
         completer.complete(response["tests"]);
       }
     });
 
     try {
-      return new Suite((await completer.future).map((test) {
+      var suite = new Suite((await completer.future).map((test) {
         var testMetadata = new Metadata.deserialize(test['metadata']);
         return new IsolateTest(test['name'], testMetadata, test['sendPort']);
-      }), metadata: metadata, path: path, platform: "VM");
+      }),
+          metadata: metadata,
+          path: path,
+          platform: "VM",
+          onClose: isolate.kill);
+      _suites.add(suite);
+      return suite;
     } finally {
       subscription.cancel();
     }
   }
 
   /// Closes the loader and releases all resources allocated by it.
   Future close() {
     return _closeThunk.run(() async {
-      for (var isolate in _isolates) {
-        isolate.kill();
-      }
-      _isolates.clear();
+      await Future.wait(_suites.map((suite) => suite.close()));
+      _suites.clear();
 
       if (!_browserServerThunk.hasRun) return;
       await (await _browserServer).close();
     });
   }
 }