Pump the event queue manually rather than using a timer.

pkg/scheduled_test/test/scheduled_test_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.
 
 library scheduled_test_test;
 
 import 'dart:async';
 
 import 'package:scheduled_test/scheduled_test.dart';
-import 'package:scheduled_test/src/utils.dart';
+
 import 'metatest.dart';
+import 'utils.dart';
 
 void main() {
   expectTestsPass('a scheduled test with a correct synchronous expectation '
       'should pass', () {
     test('test', () {
       expect('foo', equals('foo'));
     });
   });
 
   expectTestsFail('a scheduled test with an incorrect synchronous expectation '
@@ skipping 66 matching lines @@
     test('asynchronous value', () {
       var future = schedule(() => new Future.immediate('value'));
       expect(future, completion(equals('value')));
     });
   });
 
   expectTestsPass('scheduled blocks should wait for their Future return values '
       'to complete before proceeding', () {
     test('test', () {
       var value = 'unset';
-      schedule(() => sleep(50).then((_) {
+      schedule(() => pumpEventQueue().then((_) {
         value = 'set';
       }));
       schedule(() => expect(value, equals('set')));
     });
   });
 
   expectTestsFail('a test failure in a chained future in a scheduled block '
       'should be registered', () {
     test('test', () {
       schedule(() => new Future.immediate('foo')
           .then((v) => expect(v, equals('bar'))));
     });
   });
 
   expectTestsFail('an error in a chained future in a scheduled block should be '
       'registered', () {
     test('test', () {
       schedule(() => new Future.immediate(null).then((_) {
         throw 'error';
       }));
     });
   });
 
   expectTestsFail('an out-of-band failure in wrapAsync is handled', () {
     test('test', () {
+      var waiter = new Waiter();
       schedule(() {
-        sleep(10).then(wrapAsync((_) => expect('foo', equals('bar'))));
+        waiter.wait(1).then(wrapAsync((_) => expect('foo', equals('bar'))));
       });
-      schedule(() => sleep(50));
+      schedule(() => waiter.wait(2));
     });
   });
 
   expectTestsFail('an out-of-band failure in wrapAsync that finishes after the '
       'schedule is handled', () {
     test('test', () {
+      var waiter = new Waiter();
       schedule(() {
-        sleep(50).then(wrapAsync((_) => expect('foo', equals('bar'))));
+        waiter.wait(2).then(wrapAsync((_) => expect('foo', equals('bar'))));
       });
-      schedule(() => sleep(10));
+      schedule(() => waiter.wait(1));
     });
   });
 
   expectTestsFail('an out-of-band error reported via signalError is '
       'handled', () {
     test('test', () {
+      var waiter = new Waiter();
       schedule(() {
-        sleep(10).then((_) => currentSchedule.signalError('bad'));
+        waiter.wait(1).then((_) => currentSchedule.signalError('bad'));
       });
-      schedule(() => sleep(50));
+      schedule(() => waiter.wait(2));
     });
   });
 
   expectTestsFail('an out-of-band error reported via signalError that finished '
       'after the schedule is handled', () {
     test('test', () {
+      var waiter = new Waiter();
       schedule(() {
         var done = wrapAsync((_) {});
-        sleep(50).then((_) {
+        waiter.wait(2).then((_) {
           currentSchedule.signalError('bad');
           done(null);
         });
       });
-      schedule(() => sleep(10));
+      schedule(() => waiter.wait(1));
     });
   });
 
   expectTestsFail('a synchronous error reported via signalError is handled', () {
     test('test', () {
       currentSchedule.signalError('bad');
     });
   });
 
   expectTestsPass('the onComplete queue is run if a test is successful', () {
@@ skipping 12 matching lines @@
   });
 
   expectTestsPass('the onComplete queue is run after an out-of-band callback',
       () {
     var outOfBandRun = false;
     test('test1', () {
       currentSchedule.onComplete.schedule(() {
         expect(outOfBandRun, isTrue);
       });
 
-      sleep(50).then(wrapAsync((_) {
+      pumpEventQueue().then(wrapAsync((_) {
         outOfBandRun = true;
       }));
     });
   });
 
   expectTestsPass('the onComplete queue is run after an out-of-band callback '
       'and waits for another out-of-band callback', () {
     var outOfBand1Run = false;
     var outOfBand2Run = false;
     test('test1', () {
       currentSchedule.onComplete.schedule(() {
         expect(outOfBand1Run, isTrue);
 
-        sleep(50).then(wrapAsync((_) {
+        pumpEventQueue().then(wrapAsync((_) {
           outOfBand2Run = true;
         }));
       });
 
-      sleep(50).then(wrapAsync((_) {
+      pumpEventQueue().then(wrapAsync((_) {
         outOfBand1Run = true;
       }));
     });
 
     test('test2', () => expect(outOfBand2Run, isTrue));
   });
 
   expectTestsFail('an out-of-band callback in the onComplete queue blocks the '
       'test', () {
-    var outOfBandRun = false;
     test('test', () {
       currentSchedule.onComplete.schedule(() {
-        sleep(50).then(wrapAsync((_) => expect('foo', equals('bar'))));
+        pumpEventQueue().then(wrapAsync((_) => expect('foo', equals('bar'))));
       });
     });
   });
 
   expectTestsPass('an out-of-band callback blocks onComplete even with an '
       'unrelated error', () {
     var outOfBandRun = false;
     var outOfBandSetInOnComplete = false;
     test('test 1', () {
       currentSchedule.onComplete.schedule(() {
         outOfBandSetInOnComplete = outOfBandRun;
       });
 
-      sleep(50).then(wrapAsync((_) {
+      pumpEventQueue().then(wrapAsync((_) {
         outOfBandRun = true;
       }));
 
       schedule(() => expect('foo', equals('bar')));
     });
 
     test('test 2', () => expect(outOfBandSetInOnComplete, isTrue));
   }, passing: ['test 2']);
 
   expectTestsPass('the onComplete queue is run after an asynchronous error',
@@ skipping 27 matching lines @@
     });
   }, passing: ['test 2']);
 
   expectTestsPass('the onComplete queue is run after an out-of-band error', () {
     var onCompleteRun = false;
     test('test 1', () {
       currentSchedule.onComplete.schedule(() {
         onCompleteRun = true;
       });
 
-      sleep(50).then(wrapAsync((_) => expect('foo', equals('bar'))));
+      pumpEventQueue().then(wrapAsync((_) => expect('foo', equals('bar'))));
     });
 
     test('test 2', () {
       expect(onCompleteRun, isTrue);
     });
   }, passing: ['test 2']);
 
   expectTestsPass('currentSchedule.errors contains the error in the onComplete '
       'queue', () {
     var errors;
@@ skipping 81 matching lines @@
     });
   }, passing: ['test 2']);
 
   expectTestsPass('the onException queue is run after an out-of-band error', () {
     var onExceptionRun = false;
     test('test 1', () {
       currentSchedule.onException.schedule(() {
         onExceptionRun = true;
       });
 
-      sleep(50).then(wrapAsync((_) => expect('foo', equals('bar'))));
+      pumpEventQueue().then(wrapAsync((_) => expect('foo', equals('bar'))));
     });
 
     test('test 2', () {
       expect(onExceptionRun, isTrue);
     });
   }, passing: ['test 2']);
 
   expectTestsPass('currentSchedule.errors contains the error in the '
       'onException queue', () {
     var errors;
@@ skipping 46 matching lines @@
   }, passing: ['test 2']);
 
   expectTestsPass('currentSchedule.errors contains an error passed into '
       'signalError out-of-band', () {
     var errors;
     test('test 1', () {
       currentSchedule.onException.schedule(() {
         errors = currentSchedule.errors;
       });
 
-      sleep(50).then(wrapAsync((_) => currentSchedule.signalError('error')));
+      pumpEventQueue().then(wrapAsync((_) {
+        return currentSchedule.signalError('error');
+      }));
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.map((e) => e.error), equals(['error']));
     });
   }, passing: ['test 2']);
 
   expectTestsPass('currentSchedule.errors contains errors from both the task '
       'queue and the onException queue in onComplete', () {
@@ skipping 18 matching lines @@
 
   expectTestsPass('currentSchedule.errors contains multiple out-of-band errors '
       'from both the main task queue and onException in onComplete', () {
     var errors;
     test('test 1', () {
       currentSchedule.onComplete.schedule(() {
         errors = currentSchedule.errors;
       });
 
       currentSchedule.onException.schedule(() {
-        sleep(25).then(wrapAsync((_) {
+        var exceptionWaiter = new Waiter();
+        exceptionWaiter.wait(1).then(wrapAsync((_) {
           throw 'error3';
         }));
-        sleep(50).then(wrapAsync((_) {
+        exceptionWaiter.wait(2).then(wrapAsync((_) {
           throw 'error4';
         }));
       });
 
-      sleep(25).then(wrapAsync((_) {
+      var waiter = new Waiter();
+      waiter.wait(1).then(wrapAsync((_) {
         throw 'error1';
       }));
-      sleep(50).then(wrapAsync((_) {
+      waiter.wait(2).then(wrapAsync((_) {
         throw 'error2';
       }));
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.map((e) => e.error),
           orderedEquals(['error1', 'error2', 'error3', 'error4']));
     });
   }, passing: ['test 2']);
 
   expectTestsPass('currentSchedule.errors contains both an out-of-band error '
       'and an error raised afterwards in a task', () {
     var errors;
     test('test 1', () {
       currentSchedule.onComplete.schedule(() {
         errors = currentSchedule.errors;
       });
 
-      sleep(25).then(wrapAsync((_) {
+      var waiter = new Waiter();
+      waiter.wait(1).then(wrapAsync((_) {
         throw 'out-of-band';
       }));
 
-      schedule(() => sleep(50).then((_) {
+      schedule(() => waiter.wait(2).then((_) {
         throw 'in-band';
       }));
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.map((e) => e.error), equals(['out-of-band', 'in-band']));
     });
   }, passing: ['test 2']);
 
@@ skipping 16 matching lines @@
       schedule(() => expect('foo', equals('foo')));
 
       expect(currentSchedule.currentTask, isNull);
     });
   });
 
   expectTestsPass('currentSchedule.currentTask is null after the schedule has '
       'completed', () {
     test('test', () {
       schedule(() {
-        expect(sleep(50).then((_) {
+        expect(pumpEventQueue().then((_) {
           expect(currentSchedule.currentTask, isNull);
         }), completes);
       });
 
       schedule(() => expect('foo', equals('foo')));
     });
   });
 
   expectTestsPass('currentSchedule.currentQueue returns the current queue while '
       'executing a task', () {
@@ skipping 134 matching lines @@
       });
     });
 
     group('group 2', () {
       test('test 2', () {
         expect(setUpRun, isFalse);
       });
     });
   });
 }