Run test tearDowns and clean up temporary directories when a signal is caught.

lib/src/runner/browser/compiler_pool.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.util.compiler_pool;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
@@ skipping 17 matching lines @@
   final bool _color;
 
   /// The currently-active compilers.
   ///
   /// The first one is the only visible the compiler; the rest will become
   /// visible in queue order. Note that some of these processes may actually
   /// have already exited; they're kept around so that their output can be
   /// emitted once they become visible.
   final _compilers = new Queue<_Compiler>();
 
+  /// Whether [close] has been called.
+  bool get _closed => _closeCompleter != null;
+
+  /// The completer for the [Future] returned by [close].
+  Completer _closeCompleter;
+
   /// Creates a compiler pool that runs up to [parallel] instances of `dart2js`
   /// at once.
   ///
   /// If [parallel] isn't provided, it defaults to 4.
   ///
   /// If [color] is true, `dart2js` will be run with colors enabled.
   CompilerPool({int parallel, bool color: false})
       : _pool = new Pool(parallel == null ? 4 : parallel),
         _color = color;
 
   /// Compile the Dart code at [dartPath] to [jsPath].
   ///
   /// This wraps the Dart code in the standard browser-testing wrapper. If
   /// [packageRoot] is provided, it's used as the package root for the
   /// compilation.
   ///
   /// The returned [Future] will complete once the `dart2js` process completes
   /// *and* all its output has been printed to the command line.
   Future compile(String dartPath, String jsPath, {String packageRoot}) {
     return _pool.withResource(() {
+      if (_closed) return null;
+
       return withTempDir((dir) {
         var wrapperPath = p.join(dir, "runInBrowser.dart");
         new File(wrapperPath).writeAsStringSync('''
 import "package:test/src/runner/browser/iframe_listener.dart";
 
 import "${p.toUri(p.absolute(dartPath))}" as test;
 
 void main(_) {
   IframeListener.start(() => test.main);
 }
@@ skipping 28 matching lines @@
   void _showProcess(_Compiler compiler) {
     print("Compiling ${compiler.path}...");
 
     // We wait for stdout and stderr to close and for exitCode to fire to ensure
     // that we're done printing everything about one process before we start the
     // next.
     Future.wait([
       compiler.process.stdout.listen(stdout.add).asFuture(),
       compiler.process.stderr.listen(stderr.add).asFuture(),
       compiler.process.exitCode.then((exitCode) {
-        if (exitCode == 0) return;
+        if (exitCode == 0 || _closed) return;
         throw new LoadException(compiler.path, "dart2js failed.");
       })
-    ]).then(compiler.onDoneCompleter.complete)
-        .catchError(compiler.onDoneCompleter.completeError)
-        .then((_) {
+    ]).then((_) {
+      if (_closed) return;
+      compiler.onDoneCompleter.complete();
+    }).catchError((error, stackTrace) {
+      if (_closed) return;
+      compiler.onDoneCompleter.completeError(error, stackTrace);
+    }).then((_) {
+      if (_closed) return;
+
       _compilers.removeFirst();
       if (_compilers.isEmpty) return;
 
       var next = _compilers.first;
 
       // Wait a bit before printing the next progress in case the current one
       // threw an error that needs to be printed.
       Timer.run(() => _showProcess(next));
     });
   }
+
+  /// Closes the compiler pool.
+  ///
+  /// This kills all currently-running compilers and ensures that no more will
+  /// be started. It returns a [Future] that completes once all the compilers
+  /// have been killed and all resources released.
+  Future close() {
+    if (_closed) return _closeCompleter.future;
+    _closeCompleter = new Completer();
+
+    return Future.wait(_compilers.map((compiler) {
+      compiler.process.kill();
+      return compiler.process.exitCode.then(compiler.onDoneCompleter.complete);
+    })).then((_) {
+      _compilers.clear();
+      _closeCompleter.complete();
+    }).catchError(_closeCompleter.completeError);
+  }
 }
 
 /// A running instance of `dart2js`.
 class _Compiler {
   /// The path of the Dart file being compiled.
   final String path;
 
   /// The underlying process.
   final Process process;
 
   /// A future that will complete once this instance has finished running and
   /// all its output has been printed.
   Future get onDone => onDoneCompleter.future;
   final onDoneCompleter = new Completer();
 
   _Compiler(this.path, this.process);
 }