Make the unittest's breath test a bit more resilient against timing issue.

pkg/unittest/test/breath_test.dart

 // Copyright (c) 2012, 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 unittest.breath_test;
 
 import 'dart:async';
 
 import 'package:unittest/unittest.dart';
 
 void main() {
   // Test the sync test 'breath' feature of unittest.
 
   group('breath', () {
     var sentinel = 0;
     var start;
 
     test('initial', () {
+      start = new DateTime.now().millisecondsSinceEpoch;
       Timer.run(() {
         sentinel = 1;
       });
     });
 
     test('starve', () {
-      start = new DateTime.now().millisecondsSinceEpoch;
-      var now;
-      do {
+      var now = new DateTime.now().millisecondsSinceEpoch;
+      while (now - start <= BREATH_INTERVAL) {
+        // If less than BREATH_INTERVAL time has passed since
+        // we scheduled the 'initial' timer it implies the
+        // current test is being run as a microtask which is
+        // again run before any timer callbacks. Hence the
+        // sentinel should not be 1.
         expect(sentinel, 0);
         now = new DateTime.now().millisecondsSinceEpoch;
-      } while (now - start <= BREATH_INTERVAL);
+      };
+      // At this point we know at least BREATH_INTERVAL time has
+      // passed since we scheduled the Timer with the sentinel
+      // assignment. This means the next test should be scheduled
+      // using a timer as well. This ensures it will run after the
+      // timer scheduled in the 'initial' test.

[kustermann, 2014/11/17 12:32:02]

This is not completely correct.

If test 'initial' takes BREATH_INTERVAL/2 + epsilon and 'starve' blocks for
another BREATH_INTERVAL/2 + epsilon, then you go out of the while loop and the
next test (i.e. 'breathed') will also be run inside a microtask. This will be
running before the 'Timer.run(() sentinel =1)' task, making this test fail.

So if I see this right you need to do something like this:

DateTime start = new DateTime.now().millisecondsSinceEpoch;
test('init', () {
  Timer.run(() {
    sentinel = 1;
  });
});

At this point, it depends on how long it took this piece of code. If it took
longer than BREATH_INTERVAL it will end up scheduling the next test in the event
loop, otherwise in a microtask queue.

The next test, is doing this then:

test('starve', () {
  var now = new DateTime.now().millisecondsSinceEpoch;
  if (now - start < BREATH_INTERVAL) {
    // now we are certain that it *MUST* this test must have been scheduled as a
microtask
    expect(sentinel, 0);
  }
  busySleep(BREATH_INTERVAL+epsilon);
});

Now since the 'starve' test is sleeping *more than* BREATH_INTERVAL, the next
test *must* be scheduled in the event loop. 


test('breathed', () {
  expect(sentinel, 1);
});

     });
 
     test('breathed', () {
       expect(sentinel, 1);
     });
   });
 }