Fix issue with async callbacks that get called synchronously while running test case function causi…

pkg/unittest/lib/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, use the pub package manager.
  * Create a pubspec.yaml file in your project and add
  * a dependency on unittest with the following lines:
@@ skipping 344 matching lines @@
   }
 
   shouldCallBack() {
     ++actualCalls;
     if (testCase.isComplete) {
       // Don't run if the test is done. We don't throw here as this is not
       // the current test, but we do mark the old test as having an error
       // if it previously passed.
       if (testCase.result == PASS) {
         testCase.error(
-            'Callback ${id}called after test case ${testCase.description} '
-            'has already been marked as done.', '');
+            'Callback ${id}called ($actualCalls) after test case '
+            '${testCase.description} has already been marked as '
+            '${testCase.result}.', '');
       }
       return false;
     } else if (maxExpectedCalls >= 0 && actualCalls > maxExpectedCalls) {
       throw new TestFailure('Callback ${id}called more times than expected '
                             '($maxExpectedCalls).');
     }
     return true;
   }
 
   after() {
     if (!complete) {
       if (minExpectedCalls > 0 && actualCalls < minExpectedCalls) return;
       if (isDone != null && !isDone()) return;
 
       // Mark this callback as complete and remove it from the testcase
       // oustanding callback count; if that hits zero the testcase is done.
       complete = true;
-      if (--testCase.callbackFunctionsOutstanding == 0 &&
-         !testCase.isComplete) {
-        testCase.pass();
-      }
+      testCase.markCallbackComplete();
     }
   }
 
   invoke([arg0 = sentinel, arg1 = sentinel, arg2 = sentinel,
           arg3 = sentinel, arg4 = sentinel]) {
     return guardAsync(() {
       if (!shouldCallBack()) {
         return;
       } else if (arg0 == sentinel) {
         return callback();
@@ skipping 406 matching lines @@
 
 /**
  * Lazily initializes the test library if not already initialized.
  */
 void ensureInitialized() {
   if (_initialized) {
     return;
   }
   _initialized = true;
   // Hook our async guard into the matcher library.
-  wrapAsync = expectAsync1;
+  wrapAsync = (f, [id]) => expectAsync1(f, id: id);
 
   _tests = <TestCase>[];
   _testRunner = _nextBatch;
   _uncaughtErrorMessage = null;
 
   if (_config == null) {
     _config = new Configuration();
   }
   _config.onInit();
 
@@ skipping 30 matching lines @@
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef dynamic TestFunction();