Refactor groups to pipe them through to the runner.

test/runner/isolate_listener_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.
 
 @TestOn("vm")
 
 import 'dart:async';
 import 'dart:isolate';
 
 import 'package:test/src/backend/invoker.dart';
@@ skipping 20 matching lines @@
 
 void main() {
   tearDown(() {
     if (_isolate != null) _isolate.kill();
     _isolate = null;
 
     if (_liveTest != null) _liveTest.close();
     _liveTest = null;
   });
 
-  test("sends a list of available tests on startup", () async {
+  test("sends a list of available tests and groups on startup", () async {
     var response = await (await _spawnIsolate(_successfulTests)).first;
     expect(response, containsPair("type", "success"));
-    expect(response, contains("tests"));
+    expect(response, contains("entries"));
 
-    var tests = response["tests"];
+    var tests = response["entries"];
     expect(tests, hasLength(3));
     expect(tests[0], containsPair("name", "successful 1"));
     expect(tests[1], containsPair("name", "successful 2"));
-    expect(tests[2], containsPair("name", "successful 3"));
+    expect(tests[2], containsPair("type", "group"));
+    expect(tests[2], containsPair("name", "successful"));
+    expect(tests[2], contains("entries"));
+    expect(tests[2]["entries"][0], containsPair("name", "successful 3"));
   });
 
   test("waits for a returned future sending a response", () async {
     var response = await (await _spawnIsolate(_asyncTests)).first;
     expect(response, containsPair("type", "success"));
-    expect(response, contains("tests"));
+    expect(response, contains("entries"));
 
-    var tests = response["tests"];
+    var tests = response["entries"];
     expect(tests, hasLength(3));
     expect(tests[0], containsPair("name", "successful 1"));
     expect(tests[1], containsPair("name", "successful 2"));
     expect(tests[2], containsPair("name", "successful 3"));
   });
 
   test("sends an error response if loading fails", () async {
     var response = await (await _spawnIsolate(_loadError)).first;
     expect(response, containsPair("type", "error"));
     expect(response, contains("error"));
@@ skipping 187 matching lines @@
   });
 }
 
 /// Loads the first test defined in [entryPoint] in another isolate.
 ///
 /// This test will be automatically closed when the test is finished.
 Future<LiveTest> _isolateTest(void entryPoint(SendPort sendPort)) async {
   var response = await (await _spawnIsolate(entryPoint)).first;
   expect(response, containsPair("type", "success"));
 
-  var testMap = response["tests"].first;
+  var testMap = response["entries"].first;
+  expect(testMap, containsPair("type", "test"));
   var metadata = new Metadata.deserialize(testMap["metadata"]);
   var test = new IsolateTest(testMap["name"], metadata, testMap["sendPort"]);
   var suite = new Suite([test]);
   _liveTest = test.load(suite);
   return _liveTest;
 }
 
 /// Spawns an isolate from [entryPoint], sends it a new [SendPort], and returns
 /// the corresponding [ReceivePort].
 ///
@@ skipping 24 matching lines @@
 /// An isolate entrypoint that returns a function with the wrong arity.
 void _wrongArity(SendPort sendPort) {
   IsolateListener.start(sendPort, new Metadata(), () => (_) {});
 }
 
 /// An isolate entrypoint that defines three tests that succeed.
 void _successfulTests(SendPort sendPort) {
   IsolateListener.start(sendPort, new Metadata(), () => () {
     test("successful 1", () {});
     test("successful 2", () {});
-    test("successful 3", () {});
+    group("successful", () => test("3", () {}));
   });
 }
 
 /// An isolate entrypoint that defines three tests asynchronously.
 void _asyncTests(SendPort sendPort) {
   IsolateListener.start(sendPort, new Metadata(), () => () {
     return new Future(() {
       test("successful 1", () {});
 
       return new Future(() {
@@ skipping 72 matching lines @@
 /// An isolate entrypoint that defines a test that prints twice.
 void _printTest(SendPort sendPort) {
   IsolateListener.start(sendPort, new Metadata(), () => () {
     test("prints", () {
       print("Hello,");
       return new Future(() => print("world!"));
     });
   });
 }