Make scheduled_test play nicer with plain unittest tests.

pkg/scheduled_test/lib/scheduled_test.dart

 // Copyright (c) 2013, 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.
 
 // TODO(nweiz): Add support for calling [schedule] while the schedule is already
 // running.
 // TODO(nweiz): Port the non-Pub-specific scheduled test libraries from Pub.
 /// A package for writing readable tests of asynchronous behavior.
 ///
 /// ## Installing ##
@@ skipping 210 matching lines @@
 void test(String description, void body()) =>
   _test(description, body, unittest.test);
 
 /// Creates a new test case with the given description and body that will be the
 /// only test run in this file. This has the same semantics as
 /// [unittest.solo_test].
 void solo_test(String description, void body()) =>
   _test(description, body, unittest.solo_test);
 
 void _test(String description, void body(), Function testFn) {
-  _ensureInitialized();
+  unittest.ensureInitialized();
   _ensureSetUpForTopLevel();
   testFn(description, () {
     var completer = new Completer();
 
     Chain.capture(() {
       _currentSchedule = new Schedule();
       return currentSchedule.run(() {
         if (_setUpFn != null) _setUpFn();
         body();
       }).catchError((error, stackTrace) {
@@ skipping 11 matching lines @@
   });
 }
 
 /// Whether or not the tests currently being defined are in a group. This is
 /// only true when defining tests, not when executing them.
 bool _inGroup = false;
 
 /// Creates a new named group of tests. This has the same semantics as
 /// [unittest.group].
 void group(String description, void body()) {
-  _ensureInitialized();
+  unittest.ensureInitialized();
   _ensureSetUpForTopLevel();
   unittest.group(description, () {
     var wasInGroup = _inGroup;
     _inGroup = true;
     body();
     _inGroup = wasInGroup;
   });
 }
 
 /// Schedules a task, [fn], to run asynchronously as part of the main task queue
@@ skipping 35 matching lines @@
 void _ensureSetUpForTopLevel() {
   if (_inGroup || _setUpForTopLevel) return;
   _setUpScheduledTest();
 }
 
 /// Registers callbacks for [unittest.setUp] and [unittest.tearDown] that set up
 /// and tear down the scheduled test infrastructure.
 void _setUpScheduledTest([void setUpFn()]) {
   if (!_inGroup) {
     _setUpForTopLevel = true;
+    var oldWrapAsync = unittest.wrapAsync;
     unittest.setUp(() {
       if (currentSchedule != null) {
         throw new StateError('There seems to be another scheduled test '
             'still running.');
       }
+
+      unittest.wrapAsync = (f, [description]) {
+        // It's possible that this setup is run before a vanilla unittest test
+        // if [unittest.test] is run in the same context as
+        // [scheduled_test.test]. In that case, [currentSchedule] will never be
+        // set and we should forward to the [unittest.wrapAsync].
+        if (currentSchedule == null) return oldWrapAsync(f, description);
+        return currentSchedule.wrapAsync(f, description);
+      };
+
       if (_setUpFn != null) {
         var parentFn = _setUpFn;
         _setUpFn = () { parentFn(); setUpFn(); };
       } else {
         _setUpFn = setUpFn;
       }
     });
 
     unittest.tearDown(() {
+      unittest.wrapAsync = oldWrapAsync;
       _currentSchedule = null;
       _setUpFn = null;
     });
   } else {
     unittest.setUp(() {
       if (_setUpFn != null) {
         var parentFn = _setUpFn;
         _setUpFn = () { parentFn(); setUpFn(); };
       } else {
         _setUpFn = setUpFn;
       }
     });
   }
 }
 
-/// Ensures that the global configuration for `scheduled_test` has been
-/// initialized.
-void _ensureInitialized() {
-  unittest.ensureInitialized();
-  unittest.wrapAsync = (f, [description]) {
-    if (currentSchedule == null) {
-      throw new StateError("Unexpected call to wrapAsync with no current "
-          "schedule.");
-    }
-
-    return currentSchedule.wrapAsync(f, description);
-  };
-}
-
 /// Like [wrapAsync], this ensures that the current task queue waits for
 /// out-of-band asynchronous code, and that errors raised in that code are
 /// handled correctly. However, [wrapFuture] wraps a [Future] chain rather than
 /// a single callback.
 ///
 /// The returned [Future] completes to the same value or error as [future].
 ///
 /// [description] provides an optional description of the future, which is
 /// used when generating error messages.
 Future wrapFuture(Future future, [String description]) {
   if (currentSchedule == null) {
     throw new StateError("Unexpected call to wrapFuture with no current "
         "schedule.");
   }
 
   return currentSchedule.wrapFuture(future, description);
 }