Add JSON protocol support for groups.

lib/src/runner/engine.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.runner.engine;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async/async.dart' hide Result;
@@ skipping 187 matching lines @@
         if (suite is LoadSuite) {
           suite = await _addLoadSuite(suite);
           if (suite == null) {
             loadResource.release();
             return;
           }
         }
 
         await _runPool.withResource(() async {
           if (_closed) return;
-          await _runGroup(suite, suite.group);
+          await _runGroup(suite, suite.group, []);
           loadResource.allowRelease(() => suite.close());
         });
       }));
     }, onDone: _group.close);
 
     return success;
   }
 
   /// Runs all the entries in [entries] in sequence.
-  Future _runGroup(RunnerSuite suite, Group group) async {
+  ///
+  /// [parents] is a list of groups that contain [group]. It may be modified,
+  /// but it's guaranteed to be in its original state once this function has
+  /// finished.
+  Future _runGroup(RunnerSuite suite, Group group, List<Group> parents) async {
     if (group.metadata.skip) {
-      await _runLiveTest(_skippedTest(suite, group));
+      await _runLiveTest(_skippedTest(suite, group, parents));
       return;
     }
 
     var setUpAllSucceeded = true;
     if (group.setUpAll != null) {
-      var liveTest = group.setUpAll.load(suite);
+      var liveTest = group.setUpAll.load(suite, groups: parents);
       await _runLiveTest(liveTest, countSuccess: false);
       setUpAllSucceeded = liveTest.state.result == Result.success;
     }
 
     if (!_closed && setUpAllSucceeded) {
-      for (var entry in group.entries) {
-        if (_closed) return;
+      parents.add(group);
+      try {
+        for (var entry in group.entries) {
+          if (_closed) return;
 
-        if (entry is Group) {
-          await _runGroup(suite, entry);
-        } else if (entry.metadata.skip) {
-          await _runLiveTest(_skippedTest(suite, entry));
-        } else {
-          var test = entry as Test;
-          await _runLiveTest(test.load(suite));
+          if (entry is Group) {
+            await _runGroup(suite, entry, parents);
+          } else if (entry.metadata.skip) {
+            await _runLiveTest(_skippedTest(suite, entry, parents));
+          } else {
+            var test = entry as Test;
+            await _runLiveTest(test.load(suite, groups: parents));
+          }
         }
+      } finally {
+        parents.remove(group);
       }
     }
 
     // Even if we're closed or setUpAll failed, we want to run all the teardowns
     // to ensure that any state is properly cleaned up.
     if (group.tearDownAll != null) {
-      var liveTest = group.tearDownAll.load(suite);
+      var liveTest = group.tearDownAll.load(suite, groups: parents);
       await _runLiveTest(liveTest, countSuccess: false);
       if (_closed) await liveTest.close();
     }
   }
 
   /// Returns a dummy [LiveTest] for a test or group marked as "skip".
-  LiveTest _skippedTest(RunnerSuite suite, GroupEntry entry) {
+  ///
+  /// [parents] is a list of groups that contain [entry].
+  LiveTest _skippedTest(RunnerSuite suite, GroupEntry entry,
+      List<Group> parents) {
     // The netry name will be `null` for the root group.
     var test = new LocalTest(entry.name ?? "(suite)", entry.metadata, () {});
 
     var controller;
     controller = new LiveTestController(suite, test, () {
       controller.setState(const State(Status.running, Result.success));
       controller.setState(const State(Status.complete, Result.success));
       controller.completer.complete();
-    }, () {});
+    }, () {}, groups: parents);
     return controller.liveTest;
   }
 
   /// Runs [liveTest].
   ///
   /// If [countSuccess] is `true` (the default), the test is put into [passed]
   /// if it succeeds. Otherwise, it's removed from [liveTests] entirely.
   Future _runLiveTest(LiveTest liveTest, {bool countSuccess: true}) async {
     _liveTests.add(liveTest);
     _active.add(liveTest);
@@ skipping 109 matching lines @@
     var futures = allLiveTests.map((liveTest) => liveTest.close()).toList();
 
     // Closing the load pool will close the test suites as soon as their tests
     // are done. For browser suites this is effectively immediate since their
     // tests shut down as soon as they're closed, but for VM suites we may need
     // to wait for tearDowns or tearDownAlls to run.
     futures.add(_loadPool.close());
     await Future.wait(futures, eagerError: true);
   }
 }