Add metadata to messages emitted by live tests.

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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import 'group.dart';
 import 'live_test.dart';
+import 'message.dart';
 import 'state.dart';
 import 'suite.dart';
 import 'test.dart';
 
 /// An implementation of [LiveTest] that's controlled by a [LiveTestController].
 class _LiveTest extends LiveTest {
   final LiveTestController _controller;
 
   Suite get suite => _controller._suite;
 
   List<Group> get groups => _controller._groups;
 
   Test get test => _controller._test;
 
   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;
+  Stream<Message> get onMessage => _controller._onMessageController.stream;
 
   Future get onComplete => _controller.completer.future;
 
   Future run() => _controller._run();
 
   Future close() => _controller._close();
 
   _LiveTest(this._controller);
 }
 
@@ skipping 41 matching lines @@
   final _onStateChangeController = new StreamController<State>
       .broadcast(sync: true);
 
   /// The controller for [LiveTest.onError].
   ///
   /// 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].
+  /// The controller for [LiveTest.onMessage].
   ///
   /// This is synchronous to ensure that events are well-ordered across multiple
   /// streams.
-  final _onPrintController = new StreamController<String>.broadcast(sync: true);
+  final _onMessageController =
+      new StreamController<Message>.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 43 matching lines @@
   /// [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) {
-    if (_onPrintController.hasListener) {
-      _onPrintController.add(line);
+  /// Emits message over [LiveTest.onMessage].
+  void message(Message message) {
+    if (_onMessageController.hasListener) {
+      _onMessageController.add(message);
     } else {
-      // Make sure all prints get surfaced one way or another to aid in
+      // Make sure all messages get surfaced one way or another to aid in
       // debugging.
-      Zone.ROOT.print(line);
+      Zone.ROOT.print(message.text);
     }
   }
 
   /// 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.");
     } else if (_isClosed) {
       throw new StateError("LiveTest.run() may not be called for a closed "
@@ skipping 14 matching lines @@
 
     if (_runCalled) {
       _onClose();
     } else {
       completer.complete();
     }
 
     return completer.future;
   }
 }