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

lib/src/backend/live_test_controller.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.backend.live_test_controller;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 92 matching lines @@
   /// Whether [run] has been called.
   var _runCalled = false;
 
   /// Whether [close] has been called.
   bool get _isClosed => _onErrorController.isClosed;
 
   /// Creates a new controller for a [LiveTest].
   ///
   /// [test] is the test being run; [suite] is the suite that contains it.
   ///
-  /// [onRun] is a function that will be called from [LiveTest.run]. It should
-  /// start the test running. The controller takes care of ensuring that
+  /// [onRun] is a function that's called from [LiveTest.run]. It should start
+  /// the test running. The controller takes care of ensuring that
   /// [LiveTest.run] isn't called more than once and that [LiveTest.onComplete]
   /// is returned.
   ///
-  /// If [onClose] is passed, it's called the first [LiveTest.close] is called.
-  /// It should clean up any resources that have been allocated for the test. It
-  /// may return a [Future].
-  LiveTestController(this._suite, this._test, void onRun(), {onClose()})
+  /// [onClose] is a function that's called the first time [LiveTest.close] is
+  /// called. It should clean up any resources that have been allocated for the
+  /// test and ensure that the test finishes quickly if it's still running. It
+  /// will only be called if [onRun] has been called first.
+  LiveTestController(this._suite, this._test, void onRun(), void onClose())
       : _onRun = onRun,
         _onClose = onClose {
     _liveTest = new _LiveTest(this);
   }
 
   /// Adds an error to the [LiveTest].
   ///
   /// This both adds the error to [LiveTest.errors] and emits it via
   /// [LiveTest.onError]. [stackTrace] is automatically converted into a [Chain]
   /// if it's not one already.
   void addError(error, StackTrace stackTrace) {
+    if (_isClosed) return;
+
     var asyncError = new AsyncError(error, new Chain.forTrace(stackTrace));
     _errors.add(asyncError);
     _onErrorController.add(asyncError);
   }
 
   /// Sets the current state of the [LiveTest] to [newState].
   ///
   /// If [newState] is different than the old state, this both sets
   /// [LiveTest.state] and emits the new state via [LiveTest.onStateChanged]. If
   /// it's not different, this does nothing.
   void setState(State newState) {
+    if (_isClosed) return;
     if (_state == newState) return;
+
     _state = newState;
     _onStateChangeController.add(newState);
   }
 
   /// Emits a line printed by the test over [LiveTest.onPrint].
   void print(String line) => _onPrintController.add(line);
 
   /// A wrapper for [_onRun] that ensures that it follows the guarantees for
   /// [LiveTest.run].
   Future _run() {
     if (_runCalled) {
       throw new StateError("LiveTest.run() may not be called more than once.");
     }
     _runCalled = true;
 
     _onRun();
     return liveTest.onComplete;
   }
 
   /// A wrapper for [_onClose] that ensures that all controllers are closed.
   Future _close() {
-    if (_isClosed) return new Future.value();
+    if (_isClosed) return completer.future;
+
     _onStateChangeController.close();
     _onErrorController.close();
-    if (!completer.isCompleted) completer.complete();
 
-    if (_onClose != null) return new Future.sync(_onClose);
-    return new Future.value();
+    if (_runCalled) {
+      _onClose();
+    } else {
+      completer.complete();
+    }
+
+    return completer.future;
   }
 }