Add JSON protocol support for groups.

lib/src/backend/live_test.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;
 
 import 'dart:async';
 
+import 'group.dart';
 import 'state.dart';
 import 'suite.dart';
 import 'test.dart';
 
 /// A runnable instance of a test.
 ///
 /// This is distinct from [Test] in order to keep [Test]. Running a test
 /// requires state, and [LiveTest] provides a view of the state of the test as
 /// it runs.
 ///
 /// If the state changes, [state] will be updated before [onStateChange] fires.
 /// Likewise, if an error is caught, it will be added to [errors] before being
 /// emitted via [onError]. If an error causes a state change, [onStateChange]
 /// will fire before [onError]. If an error or other state change causes the
 /// test to complete, [onComplete] will complete after [onStateChange] and
 /// [onError] fire.
 abstract class LiveTest {
   /// The suite within which this test is being run.
   Suite get suite;
 
+  /// The groups within which this test is being run, from the outermost to the
+  /// innermost.
+  ///
+  /// This will always contain at least the implicit top-level group.
+  List<Group> get groups;
+
   /// The running test.
   Test get test;
 
   /// The current state of the running test.
   ///
   /// This starts as [Status.pending] and [Result.success]. It will be updated
   /// before [onStateChange] fires.
   ///
   /// Note that even if this is marked [Status.complete], the test may still be
   /// running code asynchronously. A test is considered complete either once it
@@ skipping 49 matching lines @@
   /// has fired if the test completes because of an error. It's the same as the
   /// [Future] returned by [run].
   ///
   /// Note that even once this completes, the test may still be running code
   /// asynchronously. A test is considered complete either once it hits its
   /// first error or when all [expectAsync] callbacks have been called and any
   /// returned [Future] has completed, but it's possible for further processing
   /// to happen, which may cause further errors.
   Future get onComplete;
 
+  /// The name of this live test without any group prefixes.
+  String get individualName {
+    var group = groups.last;
+    if (group.name == null) return test.name;
+    if (!test.name.startsWith(group.name)) return test.name;
+
+    // The test will have the same name as the group for virtual tests created
+    // to represent skipping the entire group.
+    if (test.name.length == group.name.length) return "";
+
+    return test.name.substring(group.name.length + 1);
+  }
+
   /// Signals that this test should start running as soon as possible.
   ///
   /// A test may not start running immediately for various reasons specific to
   /// the means by which it's defined. Until it starts running, [state] will
   /// continue to be marked [Status.pending].
   ///
   /// This returns the same [Future] as [onComplete]. It may not be called more
   /// than once.
   Future run();
 
   /// Signals that this test should stop emitting events and release any
   /// resources it may have allocated.
   ///
   /// Once [close] is called, [onComplete] will complete if it hasn't already
   /// and [onStateChange] and [onError] will close immediately. This means that,
   /// if the test was running at the time [close] is called, it will never emit
   /// a [Status.complete] state-change event. Once a test is closed, [expect]
   /// and [expectAsync] will throw a [ClosedException] to help the test
   /// terminate as quickly as possible.
   ///
   /// This doesn't automatically happen after the test completes because there
   /// may be more asynchronous work going on in the background that could
   /// produce new errors.
   ///
   /// Returns a [Future] that completes once all resources are released *and*
   /// the test has completed. This allows the caller to wait until the test's
   /// tear-down logic has run.
   Future close();
 }