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

lib/src/executable.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.
 
 // TODO(nweiz): This is under lib so that it can be used by the unittest dummy
 // package. Once that package is no longer being updated, move this back into
 // bin.
 library test.executable;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:args/args.dart';
 import 'package:stack_trace/stack_trace.dart';
 
 import 'backend/test_platform.dart';
 import 'runner/reporter/compact.dart';
 import 'runner/load_exception.dart';
 import 'runner/loader.dart';
 import 'util/exit_codes.dart' as exit_codes;
 import 'util/io.dart';
 import 'utils.dart';
 
 /// The argument parser used to parse the executable arguments.
 final _parser = new ArgParser(allowTrailingOptions: true);
 
+/// A merged stream of all signals that tell the test runner to shut down
+/// gracefully.
+///
+/// Signals will only be captured as long as this has an active subscription.
+/// Otherwise, they'll be handled by Dart's default signal handler, which
+/// terminates the program immediately.
+final _signals = mergeStreams([
+  ProcessSignal.SIGTERM.watch(), ProcessSignal.SIGINT.watch()
+]);
+
 void main(List<String> args) {
   _parser.addFlag("help", abbr: "h", negatable: false,
       help: "Shows this usage information.");
   _parser.addOption("package-root", hide: true);
   _parser.addOption("name",
       abbr: 'n',
       help: 'A substring of the name of the test to run.\n'
           'Regular expression syntax is supported.');
   _parser.addOption("plain-name",
       abbr: 'N',
@@ skipping 20 matching lines @@
     _printUsage();
     return;
   }
 
   var color = options["color"];
   if (color == null) color = canUseSpecialChars;
 
   var platforms = options["platform"].map(TestPlatform.find);
   var loader = new Loader(platforms,
       packageRoot: options["package-root"], color: color);
+
+  var signalSubscription;
+  var closed = false;
+  signalSubscription = _signals.listen((_) {
+    signalSubscription.cancel();
+    closed = true;
+    loader.close();
+  });
+
   new Future.sync(() {
     var paths = options.rest;
     if (paths.isEmpty) {
       if (!new Directory("test").existsSync()) {
         throw new LoadException("test",
             "No test files were passed and the default directory doesn't "
                 "exist.");
       }
       paths = ["test"];
     }
 
     return Future.wait(paths.map((path) {
       if (new Directory(path).existsSync()) return loader.loadDir(path);
       if (new File(path).existsSync()) return loader.loadFile(path);
       throw new LoadException(path, 'Does not exist.');
     }));
   }).then((suites) {
+    if (closed) return null;
     suites = flatten(suites);
 
     var pattern;
     if (options["name"] != null) {
       if (options["plain-name"] != null) {
         _printUsage("--name and --plain-name may not both be passed.");
         exitCode = exit_codes.data;
         return null;
       }
       pattern = new RegExp(options["name"]);
@@ skipping 14 matching lines @@
           stderr.write('regular expression "${pattern.pattern}".');
         } else {
           stderr.writeln('"$pattern".');
         }
         exitCode = exit_codes.data;
         return null;
       }
     }
 
     var reporter = new CompactReporter(flatten(suites), color: color);
+
+    // Override the signal handler to close [reporter]. [loader] will still be
+    // closed in the [whenComplete] below.
+    signalSubscription.onData((_) {
+      signalSubscription.cancel();
+      closed = true;
+
+      // Wait a bit to print this message, since printing it eagerly looks weird
+      // if the tests then finish immediately.
+      var timer = new Timer(new Duration(seconds: 1), () {
+        print("Waiting for current test to finish.");
+        print("Press Control-C again to terminate immediately.");
+      });
+
+      reporter.close().then((_) => timer.cancel());
+    });
+
     return reporter.run().then((success) {
       exitCode = success ? 0 : 1;
-    }).whenComplete(() => reporter.close());
-  }).catchError((error, stackTrace) {
+    }).whenComplete(() {
+      signalSubscription.cancel();
+      return reporter.close();
+    });
+  }).whenComplete(signalSubscription.cancel).catchError((error, stackTrace) {
     if (error is LoadException) {
       stderr.writeln(error.toString(color: color));
 
       // Only print stack traces for load errors that come from the user's 
       if (error.innerError is! IOException &&
           error.innerError is! IsolateSpawnException &&
           error.innerError is! FormatException &&
           error.innerError is! String) {
         stderr.write(terseChain(stackTrace));
       }
@@ skipping 32 matching lines @@
     output = stderr;
   }
 
   output.write("""$message
 
 Usage: pub run test:test [files or directories...]
 
 ${_parser.usage}
 """);
 }