Add JSON protocol support for groups.

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';
 
+import 'group.dart';
 import 'live_test.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;
@@ skipping 19 matching lines @@
 /// part it's the caller's responsibility to make sure everything gets
 /// dispatched in the correct order.
 class LiveTestController {
   /// The [LiveTest] controlled by [this].
   LiveTest get liveTest => _liveTest;
   LiveTest _liveTest;
 
   /// The test suite that's running [this].
   final Suite _suite;
 
+  /// The groups containing [this].
+  final List<Group> _groups;
+
   /// The test that's being run.
   final Test _test;
 
   /// The function that will actually start the test running.
   final Function _onRun;
 
   /// A function to run when the test is closed.
   ///
   /// This may be `null`.
   final Function _onClose;
@@ skipping 39 matching lines @@
   ///
   /// [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.
   ///
   /// [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 {
+  ///
+  /// If [groups] is passed, it's used to populate the list of groups that
+  /// contain this test. Otherwise, `suite.group` is used.
+  LiveTestController(Suite suite, this._test, void onRun(), void onClose(),
+          {Iterable<Group> groups})
+      : _suite = suite,
+        _onRun = onRun,
+        _onClose = onClose,
+        _groups = groups == null
+            ? [suite.group]
+            : new List.unmodifiable(groups) {
     _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;
@@ skipping 51 matching lines @@
 
     if (_runCalled) {
       _onClose();
     } else {
       completer.complete();
     }
 
     return completer.future;
   }
 }