Added a way to let the outer event loop run periodically so that things like

pkg/unittest/lib/unittest.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.
 
 /**
  * A library for writing dart unit tests.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 182 matching lines @@
 
 /** Separator used between group names and test names. */
 String groupSep = ' ';
 
 final List<TestCase> _testCases = new List<TestCase>();
 
 /** Tests executed in this suite. */
 final List<TestCase> testCases = new UnmodifiableListView<TestCase>(_testCases);
 
 /**
+ * Interval (in msecs) after which synchronous tests will insert an async
+ * delay to allow DOM or other updates.
+ */
+const int BREATH_INTERVAL = 200;
+
+/**
  * The set of tests to run can be restricted by using [solo_test] and
  * [solo_group].
  * As groups can be nested we use a counter to keep track of the nest level
  * of soloing, and a flag to tell if we have seen any solo tests.
  */
 int _soloNestingLevel = 0;
 bool _soloTestSeen = false;
 
 /**
  * Setup and teardown functions for a group and its parents, the latter
@@ skipping 73 matching lines @@
 TestCase get currentTestCase =>
     (_currentTestCaseIndex >= 0 && _currentTestCaseIndex < testCases.length)
         ? testCases[_currentTestCaseIndex]
         : null;
 
 /** Whether the framework is in an initialized state. */
 bool _initialized = false;
 
 String _uncaughtErrorMessage = null;
 
+/** Time since we last gave non-sync code a chance to be scheduled. */
+int _lastBreath = new DateTime.now().millisecondsSinceEpoch;
+
 /** Test case result strings. */
 // TODO(gram) we should change these constants to use a different string
 // (so that writing 'FAIL' in the middle of a test doesn't
 // imply that the test fails). We can't do it without also changing
 // the testrunner and test.dart though.
 const PASS  = 'pass';
 const FAIL  = 'fail';
 const ERROR = 'error';
 
 /**
@@ skipping 331 matching lines @@
  * [setUp] and [tearDown] should be called within the [group] before any
  * calls to [test]. The [teardownTest] function can be asynchronous; in this
  * case it must return a [Future].
  */
 void tearDown(Function teardownTest) {
   _currentContext.testTeardown = teardownTest;
 }
 
 /** Advance to the next test case. */
 void _nextTestCase() {
-  runAsync(() {
-    _currentTestCaseIndex++;
-    _nextBatch();
-  });
+  _currentTestCaseIndex++;
+  _runTest();
 }
 
 /**
  * Utility function that can be used to notify the test framework that an
  *  error was caught outside of this library.
  */
 void _reportTestError(String msg, trace) {
  if (_currentTestCaseIndex < testCases.length) {
     final testCase = testCases[_currentTestCaseIndex];
     testCase.error(msg, trace);
@@ skipping 23 matching lines @@
   } else if (testFilter is Function) {
     filterFunction = testFilter;
   }
   _testCases.retainWhere(filterFunction);
 }
 
 /** Runs all queued tests, one at a time. */
 void runTests() {
   _ensureInitialized(false);
   _currentTestCaseIndex = 0;
-
   _config.onStart();
-
-  runAsync(() {
-    _nextBatch();
-  });
+  _runTest();

[Siggi Cherem (dart-lang), 2013/07/25 00:50:42]

I think this one needs to still call runAsync?

 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, it is
  * passed to the corresponding test.
  *
  * The value returned by [tryBody] (if any) is returned by [guardAsync].
  */
 guardAsync(Function tryBody) {
   return _guardAsync(tryBody, null, currentTestCase);
@@ skipping 23 matching lines @@
 void _registerException(TestCase testCase, e, [trace]) {
   String message = (e is TestFailure) ? e.message : 'Caught $e';
   if (testCase.result == null) {
     testCase.fail(message, trace);
   } else {
     testCase.error(message, trace);
   }
 }
 
 /**
- * Runs a batch of tests, yielding whenever an asynchronous test starts
- * running. Tests will resume executing when such asynchronous test calls
- * [done] or if it fails with an exception.
+ * Runs the next test.
  */
-void _nextBatch() {
-  while (true) {
-    if (_currentTestCaseIndex >= testCases.length) {
-      _completeTests();
-      break;
-    }
+void _runTest() {
+  if (_currentTestCaseIndex >= testCases.length) {
+    _completeTests();
+  } else {
     final testCase = testCases[_currentTestCaseIndex];
     var f = _guardAsync(testCase._run, null, testCase);
-    if (f != null) {
-      f.whenComplete(() {
-        _nextTestCase(); // Schedule the next test.
-      });
-      break;
-    }
-    _currentTestCaseIndex++;
+    f.whenComplete(() {
+      var now = new DateTime.now().millisecondsSinceEpoch;
+      if ((now - _lastBreath) >= BREATH_INTERVAL) {
+        _lastBreath = now;
+        Timer.run(_nextTestCase);
+      } else {
+        runAsync(_nextTestCase); // Schedule the next test.
+      }
+    });
   }
 }
 
 /** Publish results on the page and notify controller. */
 void _completeTests() {
   if (!_initialized) return;
   int passed = 0;
   int failed = 0;
   int errors = 0;
 
@@ skipping 92 matching lines @@
 
   if (!formatStacks) return trace;
 
   // Format the stack trace by removing everything above TestCase._runTest,
   // which is usually going to be irrelevant. Also fold together unittest and
   // core library calls so only the function the user called is visible.
   return new Trace(trace.frames.takeWhile((frame) {
     return frame.package != 'unittest' || frame.member != 'TestCase._runTest';
   })).terse.foldFrames((frame) => frame.package == 'unittest' || frame.isCore);
 }