Refactor groups to pipe them through to the runner.

lib/src/backend/invoker.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.invoker;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import '../frontend/expect.dart';
 import '../utils.dart';
 import 'closed_exception.dart';
 import 'live_test.dart';
 import 'live_test_controller.dart';
 import 'metadata.dart';
+import 'operating_system.dart';
 import 'outstanding_callback_counter.dart';
 import 'state.dart';
 import 'suite.dart';
 import 'test.dart';
+import 'test_platform.dart';
 
 /// A test in this isolate.
-class LocalTest implements Test {
+class LocalTest extends Test {
   final String name;
   final Metadata metadata;
 
   /// The test body.
   final AsyncFunction _body;
 
   LocalTest(this.name, this.metadata, body())
       : _body = body;
 
   /// Loads a single runnable instance of this test.
   LiveTest load(Suite suite) {
     var invoker = new Invoker._(suite, this);
     return invoker.liveTest;
   }
 
-  Test change({String name, Metadata metadata}) {
-    if (name == name && metadata == this.metadata) return this;
-    if (name == null) name = this.name;
-    if (metadata == null) metadata = this.metadata;
-    return new LocalTest(name, metadata, _body);
+  Test forPlatform(TestPlatform platform, {OperatingSystem os}) {
+    if (!metadata.testOn.evaluate(platform, os: os)) return null;
+    return new LocalTest(name, metadata.forPlatform(platform, os: os), _body);
   }
 }
 
 /// The class responsible for managing the lifecycle of a single local test.
 ///
 /// The current invoker is accessible within the zone scope of the running test
 /// using [Invoker.current]. It's used to track asynchronous callbacks and
 /// report asynchronous errors.
 class Invoker {
   /// The live test being driven by the invoker.
@@ skipping 22 matching lines @@
   Future get onClose => _closable
       ? _onCloseCompleter.future
       // If we're in an unclosable block, return a future that will never
       // complete.
       : new Completer().future;
   final _onCloseCompleter = new Completer();
 
   /// The test being run.
   LocalTest get _test => liveTest.test as LocalTest;
 
-  /// The test metadata merged with the suite metadata.
-  final Metadata metadata;
-
   /// The outstanding callback counter for the current zone.
   OutstandingCallbackCounter get _outstandingCallbacks {
     var counter = Zone.current[_counterKey];
     if (counter != null) return counter;
     throw new StateError("Can't add or remove outstanding callbacks outside "
         "of a test body.");
   }
 
   /// An opaque object used as a key in the zone value map to identify
   /// [_outstandingCallbacks].
@@ skipping 14 matching lines @@
   ///
   /// Tracking this ensures that [_timeoutTimer] isn't created in a
   /// timer-mocking zone created by the test.
   Zone _invokerZone;
 
   /// The timer for tracking timeouts.
   ///
   /// This will be `null` until the test starts running.
   Timer _timeoutTimer;
 
-  Invoker._(Suite suite, LocalTest test)
-      : metadata = suite.metadata.merge(test.metadata) {
+  Invoker._(Suite suite, LocalTest test) {
     _controller = new LiveTestController(
         suite, test, _onRun, _onCloseCompleter.complete);
   }
 
   /// Tells the invoker that there's a callback running that it should wait for
   /// before considering the test successful.
   ///
   /// Each call to [addOutstandingCallback] should be followed by a call to
   /// [removeOutstandingCallback] once the callbak is no longer running. Note
   /// that only successful tests wait for outstanding callbacks; as soon as a
@@ skipping 63 matching lines @@
   }
 
   /// Notifies the invoker that progress is being made.
   ///
   /// Each heartbeat resets the timeout timer. This helps ensure that
   /// long-running tests that still make progress don't time out.
   void heartbeat() {
     if (liveTest.isComplete) return;
     if (_timeoutTimer != null) _timeoutTimer.cancel();
 
-    var timeout = metadata.timeout.apply(new Duration(seconds: 30));
+    var timeout = liveTest.test.metadata.timeout
+        .apply(new Duration(seconds: 30));
     if (timeout == null) return;
     _timeoutTimer = _invokerZone.createTimer(timeout,
         Zone.current.bindCallback(() {
       if (liveTest.isComplete) return;
       _handleError(
           new TimeoutException(
               "Test timed out after ${niceDuration(timeout)}.", timeout));
     }));
   }
 
@@ skipping 61 matching lines @@
         // outstanding callback counters at once.
         _counterKey: outstandingCallbacksForBody,
         _closableKey: true
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: _handleError);
     });
   }
 }