Refactor groups to pipe them through to the runner.

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;
 import 'package:collection/collection.dart';
 import 'package:pool/pool.dart';
 
+import '../backend/group.dart';
+import '../backend/invoker.dart';
 import '../backend/live_test.dart';
 import '../backend/live_test_controller.dart';
 import '../backend/state.dart';
+import '../backend/suite_entry.dart';
 import '../backend/test.dart';
 import 'load_suite.dart';
 import 'runner_suite.dart';
 
 /// An [Engine] manages a run that encompasses multiple test suites.
 ///
 /// Test suites are provided by passing them into [suiteSink]. Once all suites
 /// have been provided, the user should close [suiteSink] to indicate this.
 /// [run] won't terminate until [suiteSink] is closed. Suites will be run in the
 /// order they're provided to [suiteSink]. Tests within those suites will
-/// likewise be run in the order of [Suite.tests].
+/// likewise be run in the order they're declared.
 ///
 /// The current status of every test is visible via [liveTests]. [onTestStarted]
 /// can also be used to be notified when a test is about to be run.
 ///
 /// The engine has some special logic for [LoadSuite]s and the tests they
 /// contain, referred to as "load tests". Load tests exist to provide visibility
 /// into the process of loading test files, but as long as that process is
 /// proceeding normally users usually don't care about it, so the engine only
 /// surfaces running load tests (that is, includes them in [liveTests] and other
 /// collections) under specific circumstances.
@@ skipping 150 matching lines @@
 
         if (suite is LoadSuite) {
           suite = await _addLoadSuite(suite);
           if (suite == null) {
             loadResource.release();
             return;
           }
         }
 
         await _runPool.withResource(() async {
-          if (_closed) return null;
-
-          // TODO(nweiz): Use a real for loop when issue 23394 is fixed.
-          await Future.forEach(suite.tests, (test) async {
-            if (_closed) return;
-
-            var liveTest = test.metadata.skip
-                ? _skippedTest(suite, test)
-                : test.load(suite);
-            _liveTests.add(liveTest);
-            _active.add(liveTest);
-
-            // If there were no active non-load tests, the current active test
-            // would have been a load test. In that case, remove it, since now we
-            // have a non-load test to add.
-            if (_active.isNotEmpty && _active.first.suite is LoadSuite) {
-              _liveTests.remove(_active.removeFirst());
-            }
-
-            liveTest.onStateChange.listen((state) {
-              if (state.status != Status.complete) return;
-              _active.remove(liveTest);
-
-              // If we're out of non-load tests, surface a load test.
-              if (_active.isEmpty && _activeLoadTests.isNotEmpty) {
-                _active.add(_activeLoadTests.first);
-                _liveTests.add(_activeLoadTests.first);
-              }
-
-              if (state.result != Result.success) {
-                _passed.remove(liveTest);
-                _failed.add(liveTest);
-              } else if (liveTest.test.metadata.skip) {
-                _skipped.add(liveTest);
-              } else {
-                _passed.add(liveTest);
-              }
-            });
-
-            _onTestStartedController.add(liveTest);
-
-            // First, schedule a microtask to ensure that [onTestStarted] fires
-            // before the first [LiveTest.onStateChange] event. Once the test
-            // finishes, use [new Future] to do a coarse-grained event loop pump
-            // to avoid starving non-microtask events.
-            await new Future.microtask(liveTest.run);
-            await new Future(() {});
-          });
-
+          if (_closed) return;
+          await _runEntries(suite, suite.entries);
           loadResource.allowRelease(() => suite.close());
         });
       }));
     }, onDone: _group.close);
 
     return success;
   }
 
-  /// Returns a dummy [LiveTest] for a test marked as "skip".
-  LiveTest _skippedTest(RunnerSuite suite, Test test) {
+  /// Runs all the entries in [entries] in sequence.
+  Future _runEntries(RunnerSuite suite, List<SuiteEntry> entries) async {
+    for (var entry in entries) {
+      if (_closed) return;
+
+      if (entry.metadata.skip) {
+        await _runLiveTest(_skippedTest(suite, entry));
+      } else if (entry is Test) {
+        await _runLiveTest(entry.load(suite));
+      } else {
+        var group = entry as Group;
+        await _runEntries(suite, group.entries);
+      }
+    }
+  }
+
+  /// Returns a dummy [LiveTest] for a test or group marked as "skip".
+  LiveTest _skippedTest(RunnerSuite suite, SuiteEntry entry) {
+    var test = new LocalTest(entry.name, 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();
     }, () {});
     return controller.liveTest;
   }
 
+  /// Runs [liveTest].
+  Future _runLiveTest(LiveTest liveTest) async {
+    _liveTests.add(liveTest);
+    _active.add(liveTest);
+
+    // If there were no active non-load tests, the current active test would
+    // have been a load test. In that case, remove it, since now we have a
+    // non-load test to add.
+    if (_active.isNotEmpty && _active.first.suite is LoadSuite) {
+      _liveTests.remove(_active.removeFirst());
+    }
+
+    liveTest.onStateChange.listen((state) {
+      if (state.status != Status.complete) return;
+      _active.remove(liveTest);
+
+      // If we're out of non-load tests, surface a load test.
+      if (_active.isEmpty && _activeLoadTests.isNotEmpty) {
+        _active.add(_activeLoadTests.first);
+        _liveTests.add(_activeLoadTests.first);
+      }
+
+      if (state.result != Result.success) {
+        _passed.remove(liveTest);
+        _failed.add(liveTest);
+      } else if (liveTest.test.metadata.skip) {
+        _skipped.add(liveTest);
+      } else {
+        _passed.add(liveTest);
+      }
+    });
+
+    _onTestStartedController.add(liveTest);
+
+    // First, schedule a microtask to ensure that [onTestStarted] fires before
+    // the first [LiveTest.onStateChange] event. Once the test finishes, use
+    // [new Future] to do a coarse-grained event loop pump to avoid starving
+    // non-microtask events.
+    await new Future.microtask(liveTest.run);
+    await new Future(() {});
+  }
+
   /// Adds listeners for [suite].
   ///
   /// Load suites have specific logic apart from normal test suites.
   Future<RunnerSuite> _addLoadSuite(LoadSuite suite) async {
-    var liveTest = await suite.tests.single.load(suite);
+    var liveTest = await suite.test.load(suite);
 
     _activeLoadTests.add(liveTest);
 
     // Only surface the load test if there are no other tests currently running.
     if (_active.isEmpty) {
       _liveTests.add(liveTest);
       _active.add(liveTest);
     }
 
     liveTest.onStateChange.listen((state) {
@@ skipping 44 matching lines @@
 
     // Close the running tests first so that we're sure to wait for them to
     // finish before we close their suites and cause them to become unloaded.
     var allLiveTests = liveTests.toSet()..addAll(_activeLoadTests);
     await Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
 
     var allSuites = allLiveTests.map((liveTest) => liveTest.suite).toSet();
     await Future.wait(allSuites.map((suite) => suite.close()));
   }
 }