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 333 matching lines @@
  * case it must return a [Future].
  */
 void tearDown(Function teardownTest) {
   _currentContext.testTeardown = teardownTest;
 }
 
 /** Advance to the next test case. */
 void _nextTestCase() {
   runAsync(() {
     _currentTestCaseIndex++;
-    _nextBatch();
+    _nextTest();
   });
 }
 
 /**
  * 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];
@@ skipping 28 matching lines @@
 }
 
 /** Runs all queued tests, one at a time. */
 void runTests() {
   _ensureInitialized(false);
   _currentTestCaseIndex = 0;
 
   _config.onStart();
 
   runAsync(() {
-    _nextBatch();
+    _nextTest();
   });
 }
 
 /**
  * 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) {
@@ skipping 24 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 _nextTest() {
+  if (_currentTestCaseIndex >= testCases.length) {
+    _completeTests();
+  } else {
     final testCase = testCases[_currentTestCaseIndex];
     var f = _guardAsync(testCase._run, null, testCase);
-    if (f != null) {
-      f.whenComplete(() {
+    f.whenComplete(() {
+      var now = new DateTime.now().millisecondsSinceEpoch;
+      if ((now - _lastBreath) >= BREATH_INTERVAL) {

[Siggi Cherem (dart-lang), 2013/07/24 23:34:06]

consider moving this test up to _nextTestCase? then the question is just whether
to do runAsync or Timer.run there?

[gram, 2013/07/24 23:54:52]

_nextTestCase first increments the counter so there is a difference. I have
renamed this to _runTest which is a bit more accurate and makes the distinction
with _nextTestCase a bit clearer.

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

basically it seems strange that we do runAsync on one case and Timer.run +
runAsync in the other.

Maybe remove runAsync from nextTestcase, but put it below in the else branch?

[gram, 2013/07/25 00:33:22]

Done.

+        _lastBreath = now;
+        new Future(_nextTestCase);

[Siggi Cherem (dart-lang), 2013/07/24 23:34:06]

isn't this the same as runAsync(_nextTestCase).

If we want to explicitly let the DOM run, we'd need to do
Timer.run(_nextTextCase)

[gram, 2013/07/24 23:54:52]

Done.

+      } else {
         _nextTestCase(); // Schedule the next test.
-      });
-      break;
-    }
-    _currentTestCaseIndex++;
+      }
+    });
   }
 }
 
 /** 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);
 }