aChange all asyncTest/callbackDone style tests to use the new expectAsync/

lib/unittest/unittest.dart

 // Copyright (c) 2011, 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.
  *
  * To import this library, specify the relative path to 
  * lib/unittest/unittest.dart.
  *
@@ skipping 356 matching lines @@
 Function expectAsync0(Function callback, [int count = 1]) {
   return new _SpreadArgsHelper(callback, count).invoke0;
 }
 
 /** Like [expectAsync0] but [callback] should take 1 positional argument. */
 // TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function expectAsync1(Function callback, [int count = 1]) {
   return new _SpreadArgsHelper(callback, count).invoke1;
 }
 
-/** Like [expectAsync0] but [callback] should take 1 positional argument. */
+/** Like [expectAsync0] but [callback] should take 2 positional arguments. */
 // TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function expectAsync2(Function callback, [int count = 1]) {
   return new _SpreadArgsHelper(callback, count).invoke2;
 }
 
 /**
  * Creates a new named group of tests. Calls to group() or test() within the
  * body of the function passed to this will inherit this group's description.
  */
 void group(String description, void body()) {
@@ skipping 12 matching lines @@
   try {
     body();
   } finally {
     // Now that the group is over, restore the previous one.
     _currentGroup = oldGroup;
   }
 }
 
 /** Called by subclasses to indicate that an asynchronous test completed. */
 void callbackDone() {
-  _callbacksCalled++;
-  if (_currentTest < _tests.length) {
-    final testCase = _tests[_currentTest];
-    if (_callbacksCalled > testCase.callbacks) {
-      final expected = testCase.callbacks;
-      testCase.error(
-          'More calls to callbackDone() than expected. '
-          'Actual: ${_callbacksCalled}, expected: ${expected}', '');
-      _state = _UNCAUGHT_ERROR;
-    } else if ((_callbacksCalled == testCase.callbacks) &&
-        (_state != _RUNNING_TEST)) {
-      if (testCase.result == null) testCase.pass();
-      _currentTest++;
-      _testRunner();
+  // TODO (gram): we defer this to give the nextBatch recursive
+  // stack a chance to unwind. This is a temporary hack but 
+  // really a bunch of code here needs to be fixed. We have a 
+  // single array that is being iterated through by a function
+  // that is recursively invoked in the case of async tests.

[Siggi Cherem (dart-lang), 2012/05/21 22:20:47]

can we clarify here why recursive calls happen. In particular, if callbacks are
invoked asynchronously, nothing bad happens. Bad things happen when a test is
written in an asynchronous fashion, but the code runs sychronously.

[gram, 2012/05/22 17:36:36]

Done.

+  // Bad things can happen.
+  _defer(() {
+    _callbacksCalled++;
+    if (_currentTest < _tests.length) {
+      final testCase = _tests[_currentTest];
+      if (_callbacksCalled > testCase.callbacks) {
+        final expected = testCase.callbacks;
+        testCase.error(
+            'More calls to callbackDone() than expected. '
+            'Actual: ${_callbacksCalled}, expected: ${expected}', '');
+        _state = _UNCAUGHT_ERROR;
+      } else if ((_callbacksCalled == testCase.callbacks) &&
+          (_state != _RUNNING_TEST)) {
+        if (testCase.result == null) testCase.pass();
+        _currentTest++;
+        _testRunner();
+      }
     }
-  }
+  });
 }
 
 /** Menchanism to notify that an error was caught outside of this library. */
 void reportTestError(String msg, String trace) {
  if (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
     testCase.error(msg, trace);
     _state = _UNCAUGHT_ERROR;
     if (testCase.callbacks > 0) {
       _currentTest++;
@@ skipping 33 matching lines @@
 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, update
  * the [_currentTest] status accordingly.
  */
 guardAsync(tryBody, [finallyBody]) {
   try {
     return tryBody();
   } catch (ExpectException e, var trace) {
+    Expect.isTrue(_currentTest < _tests.length);
     if (_state != _UNCAUGHT_ERROR) {
       _tests[_currentTest].fail(e.message,
           trace == null ? '' : trace.toString());
     }
   } catch (var e, var trace) {
     if (_state == _RUNNING_TEST) {
       // If a random exception is thrown from within a test, we consider that
       // a test failure too. A test case implicitly has an expectation that it
       // will run to completion without an uncaught exception being thrown.
       _tests[_currentTest].fail('Caught $e',
@@ skipping 82 matching lines @@
   }
   _config.onInit();
 
   // Immediately queue the suite up. It will run after a timeout (i.e. after
   // main() has returned).
   _defer(_runTests);
 }
 
 /** Signature for a test function. */
 typedef void TestFunction();