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

lib/src/runner/reporter/compact.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.reporter.compact;
 
 import 'dart:async';
 import 'dart:io';
 
 import '../../backend/live_test.dart';
@@ skipping 33 matching lines @@
 
   /// A stopwatch that tracks the duration of the full run.
   final _stopwatch = new Stopwatch();
 
   /// The set of tests that have completed and been marked as passing.
   final _passed = new Set<LiveTest>();
 
   /// The set of tests that have completed and been marked as failing or error.
   final _failed = new Set<LiveTest>();
 
+  /// Whether [close] has been called.
+  bool _closed = false;
+
   /// The size of [_passed] last time a progress notification was printed.
   int _lastProgressPassed;
 
   /// The size of [_failed] last time a progress notification was printed.
   int _lastProgressFailed;
 
   /// The message printed for the last progress notification.
   String _lastProgressMessage;
 
+  // Whether a newline has been printed since the last progress line.
+  var _printedNewline = true;
+
   /// Creates a [ConsoleReporter] that will run all tests in [suites].
   ///
   /// If [color] is `true`, this will use terminal colors; if it's `false`, it
   /// won't.
   CompactReporter(Iterable<Suite> suites, {bool color: true})
       : _multiplePaths = suites.map((suite) => suite.path).toSet().length > 1,
         _multiplePlatforms =
             suites.map((suite) => suite.platform).toSet().length > 1,
         _engine = new Engine(suites),
         _green = color ? '\u001b[32m' : '',
         _red = color ? '\u001b[31m' : '',
         _noColor = color ? '\u001b[0m' : '' {
-    // Whether a newline has been printed since the last progress line.
-    var printedNewline = false;
     _engine.onTestStarted.listen((liveTest) {
       _progressLine(_description(liveTest));
+      _printedNewline = false;
+
       liveTest.onStateChange.listen((state) {
         if (state.status != Status.complete) return;
         if (state.result == Result.success) {
           _passed.add(liveTest);
         } else {
           _passed.remove(liveTest);
           _failed.add(liveTest);
         }
         _progressLine(_description(liveTest));
-        printedNewline = false;
+        _printedNewline = false;
       });
 
       liveTest.onError.listen((error) {
         if (liveTest.state.status != Status.complete) return;
 
         _progressLine(_description(liveTest));
-        if (!printedNewline) print('');
-        printedNewline = true;
+        if (!_printedNewline) print('');
+        _printedNewline = true;
 
         print(indent(error.error.toString()));
         print(indent(terseChain(error.stackTrace).toString()));
       });
 
       liveTest.onPrint.listen((line) {
         _progressLine(_description(liveTest));
-        if (!printedNewline) print('');
-        printedNewline = true;
+        if (!_printedNewline) print('');
+        _printedNewline = true;
 
         print(line);
       });
     });
   }
 
   /// Runs all tests in all provided suites.
   ///
   /// This returns `true` if all tests succeed, and `false` otherwise. It will
   /// only return once all tests have finished running.
   Future<bool> run() {
     if (_stopwatch.isRunning) {
       throw new StateError("CompactReporter.run() may not be called more than "
           "once.");
     }
 
     if (_engine.liveTests.isEmpty) {
       print("No tests ran.");
       return new Future.value(true);
     }
 
     _stopwatch.start();
     return _engine.run().then((success) {
+      if (_closed) return false;
+
       if (success) {
         _progressLine("All tests passed!");
         print('');
       } else {
         _progressLine('Some tests failed.', color: _red);
         print('');
       }
 
       return success;
     });
   }
 
   /// Signals that the caller is done with any test output and the reporter
   /// should release any resources it has allocated.
-  Future close() => _engine.close();
+  Future close() {
+    if (!_printedNewline) print("");
+    _printedNewline = true;
+    _closed = true;
+    return _engine.close();
+  }
 
   /// Prints a line representing the current state of the tests.
   ///
   /// [message] goes after the progress report, and may be truncated to fit the
   /// entire line within [_lineLength]. If [color] is passed, it's used as the
   /// color for [message].
   bool _progressLine(String message, {String color}) {
     // Print nothing if nothing has changed since the last progress line.
     if (_passed.length == _lastProgressPassed &&
         _failed.length == _lastProgressFailed &&
@@ skipping 59 matching lines @@
       name = "${liveTest.suite.path}: $name";
     }
 
     if (_multiplePlatforms && liveTest.suite.platform != null) {
       name = "[${liveTest.suite.platform}] $name";
     }
 
     return name;
   }
 }