Gracefully handle tests that print.

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 unittest.backend.live_test_controller;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 14 matching lines @@
 
   State get state => _controller._state;
 
   Stream<State> get onStateChange =>
       _controller._onStateChangeController.stream;
 
   List<AsyncError> get errors => new UnmodifiableListView(_controller._errors);
 
   Stream<AsyncError> get onError => _controller._onErrorController.stream;
 
+  Stream<String> get onPrint => _controller._onPrintController.stream;
+
   Future get onComplete => _controller.completer.future;
 
   Future run() => _controller._run();
 
   Future close() => _controller._close();
 
   _LiveTest(this._controller);
 }
 
 /// A controller that drives a [LiveTest].
@@ skipping 24 matching lines @@
   /// This may be `null`.
   final AsyncFunction _onClose;
 
   /// The list of errors caught by the test.
   final _errors = new List<AsyncError>();
 
   /// The current state of the test.
   var _state = const State(Status.pending, Result.success);
 
   /// The controller for [LiveTest.onStateChange].
-  final _onStateChangeController = new StreamController<State>.broadcast();
+  ///
+  /// This is synchronous to ensure that events are well-ordered across multiple
+  /// streams.
+  final _onStateChangeController = new StreamController<State>
+      .broadcast(sync: true);
 
   /// The controller for [LiveTest.onError].
-  final _onErrorController = new StreamController<AsyncError>.broadcast();
+  ///
+  /// This is synchronous to ensure that events are well-ordered across multiple
+  /// streams.
+  final _onErrorController = new StreamController<AsyncError>
+      .broadcast(sync: true);
+
+  /// The controller for [LiveTest.onPrint].
+  ///
+  /// This is synchronous to ensure that events are well-ordered across multiple
+  /// streams.
+  final _onPrintController = new StreamController<String>.broadcast(sync: true);
 
   /// The completer for [LiveTest.onComplete];
   final completer = new Completer();
 
   /// Whether [run] has been called.
   var _runCalled = false;
 
   /// Whether [close] has been called.
   bool get _isClosed => _onErrorController.isClosed;
 
@@ skipping 30 matching lines @@
   ///
   /// 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 (_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();
     _onStateChangeController.close();
     _onErrorController.close();
     if (!completer.isCompleted) completer.complete();
 
     if (_onClose != null) return new Future.sync(_onClose);
     return new Future.value();
   }
 }