Some unit test fixes:

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 136 matching lines @@
 #source('map_matchers.dart');
 #source('matcher.dart');
 #source('numeric_matchers.dart');
 #source('operator_matchers.dart');
 #source('string_matchers.dart');
 #source('test_case.dart');
 
 /** [Configuration] used by the unittest library. */
 Configuration _config = null;
 
-/** Set the [Configuration] used by the unittest library. */
+/** Set the [Configuration] used by the unittest library.*/

[Bob Nystrom, 2012/06/13 23:52:29]

?

[gram, 2012/06/14 00:50:58]

Done.

 void configure(Configuration config) {
   _config = config;
 }
 
 /**
  * Description text of the current test group. If multiple groups are nested,
  * this will contain all of their text concatenated.
  */
 String _currentGroup = '';
 
@@ skipping 121 matching lines @@
 
 // TODO(sigmund): make a singleton const field when frog supports passing those
 // as default values to named arguments.
 final _sentinel = const _Sentinel();
 
 /** Simulates spread arguments using named arguments. */
 // TODO(sigmund): remove this class and simply use a closure with named
 // arguments inside [_expectAsync], once bug 282 is fixed or frog is replaced by
 // dart2js.
 class _SpreadArgsHelper {
-  Function callback;
-  int expectedCalls;
-  int calls = 0;
-  TestCase testCase;
-  _SpreadArgsHelper(this.callback, this.expectedCalls) {
+  Function _callback;
+  int _expectedCalls;
+  int _calls = 0;
+  TestCase _testCase;
+  Function _shouldCallBack;
+  Function _isDone;
+
+  _Init(Function callback, Function shouldCallBack, Function isDone,

[Siggi Cherem (dart-lang), 2012/06/13 23:43:53]

-> lower case.

[Bob Nystrom, 2012/06/13 23:52:29]

Can you use a delegating constructor for this? Something like:

// turn _Init into:
_SpreadArgsHelper(...) { }

// And then make the constructor calls like:
_SpreadArgsHelper.fixedCallCount(...) : this(...)

I know Dart is supposed to support this, but I'm not sure if it's implemented
yet, or if I have the right syntax.

[gram, 2012/06/14 00:50:58]

Done.

[gram, 2012/06/14 00:50:58]

I tried this originally. It didn't work because seemingly you can't reference
other methods like _allCallsDone from within the referenced constructor call. I
had to move that into the constructor body, hence _init.

+       [expectedCalls = 0]) {
     Expect.isTrue(_currentTest < _tests.length);

[Bob Nystrom, 2012/06/13 23:52:29]

This Expect call is weird. Make it an assert instead, or remove it?

[gram, 2012/06/14 00:50:58]

Made assert.

-    testCase = _tests[_currentTest];
-    testCase.callbacks++;
+    _callback = callback;
+    _shouldCallBack = shouldCallBack;
+    _isDone = isDone;
+    _expectedCalls = expectedCalls;
+    _testCase = _tests[_currentTest];
+    _testCase.callbacks++;
+  }
+
+  _SpreadArgsHelper( callback, shouldCallBack, isDone) {

[Siggi Cherem (dart-lang), 2012/06/13 23:43:53]

remove extra space

[Bob Nystrom, 2012/06/13 23:52:29]

No space after '('.

[gram, 2012/06/14 00:50:58]

Done.

[gram, 2012/06/14 00:50:58]

Done.

+    _Init(callback, shouldCallBack, isDone);
+  }
+
+  _SpreadArgsHelper.fixedCallCount(callback, expectedCalls) {

[Siggi Cherem (dart-lang), 2012/06/13 23:43:53]

let's make _callback final and change all 3 constructors to say 'this._callback'

[gram, 2012/06/14 00:50:58]

Tried this; it doesn't work for the same reason delegating constructors don't
work. Well, it could be done for callback, but not the other members (which can
be initialized to point to methods within _SpreadArgsHelper), and that gets
weird, so I think it is more consistent to leave it as is.

+    _Init(callback, _checkCallCount, _allCallsDone, expectedCalls);
+  }
+
+  _SpreadArgsHelper.variableCallCount(callback, isDone) {
+    _Init(callback, _always, isDone);
+  }
+
+  _after() {
+    if (_isDone())

[Siggi Cherem (dart-lang), 2012/06/13 23:43:53]

style: add { } or merge this and the next line in a single line.

[gram, 2012/06/14 00:50:58]

Done.

+      _handleAllCallbacksDone();

[Bob Nystrom, 2012/06/13 23:52:29]

Make this one line or use {}.

[gram, 2012/06/14 00:50:58]

Done.

+  }
+
+  _allCallsDone() {

[Bob Nystrom, 2012/06/13 23:52:29]

Make this an =>?

[gram, 2012/06/14 00:50:58]

Done.

+    return (_calls == _expectedCalls);
+  }
+
+  _always() {
+    // always run except if the test is done

[Bob Nystrom, 2012/06/13 23:52:29]

Full sentence: "Always... done."

[gram, 2012/06/14 00:50:58]

Done.

+    if (_testCase.isComplete) {
+      _testCase.error(
+        'Callback called after already being marked as done ($_calls)',

[Bob Nystrom, 2012/06/13 23:52:29]

Indent another 2.

[gram, 2012/06/14 00:50:58]

Done.

+        '');
+     _state = _UNCAUGHT_ERROR;

[Bob Nystrom, 2012/06/13 23:52:29]

Indent +1.

[gram, 2012/06/14 00:50:58]

Done.

+     return false;
+    } else {
+      return true;
+    }
   }
 
   invoke([arg0 = _sentinel, arg1 = _sentinel, arg2 = _sentinel,
           arg3 = _sentinel, arg4 = _sentinel]) {
     return guardAsync(() {
-      if (!_incrementCall()) {
+      ++_calls;
+      if (!_shouldCallBack()) {
         return;
       } else if (arg0 == _sentinel) {
-        return callback();
+        return _callback();
       } else if (arg1 == _sentinel) {
-        return callback(arg0);
+        return _callback(arg0);
       } else if (arg2 == _sentinel) {
-        return callback(arg0, arg1);
+        return _callback(arg0, arg1);
       } else if (arg3 == _sentinel) {
-        return callback(arg0, arg1, arg2);
+        return _callback(arg0, arg1, arg2);
       } else if (arg4 == _sentinel) {
-        return callback(arg0, arg1, arg2, arg3);
+        return _callback(arg0, arg1, arg2, arg3);
       } else {
-        testCase.error(
+        _testCase.error(
            'unittest lib does not support callbacks with more than 4 arguments',
            '');
         _state = _UNCAUGHT_ERROR;
       }
-    }, () { if (calls == expectedCalls) callbackDone(); });
+    },
+    _after);
   }
 
   invoke0() {
     return guardAsync(
-        () => _incrementCall() ? callback() : null,
-        () { if (calls == expectedCalls) callbackDone(); });
+        () { if (_shouldCallBack()) _callback(); },
+        _after);
   }
 
   invoke1(arg1) {
     return guardAsync(
-        () => _incrementCall() ? callback(arg1) : null,
-        () { if (calls == expectedCalls) callbackDone(); });
+        () { if (_shouldCallBack()) _callback(arg1); },
+        _after);
   }
 
   invoke2(arg1, arg2) {
     return guardAsync(
-        () => _incrementCall() ? callback(arg1, arg2) : null,
-        () { if (calls == expectedCalls) callbackDone(); });
+        () { if (_shouldCallBack()) _callback(arg1, arg2); },
+        _after);
   }
 
   /** Returns false if we exceded the number of expected calls. */
-  bool _incrementCall() {
-    calls++;
-    if (calls > expectedCalls) {
-      testCase.error(
-         'Callback called more times than expected ($calls > $expectedCalls)',
+  bool _checkCallCount() {
+    if (_calls > _expectedCalls) {
+      _testCase.error(
+         'Callback called more times than expected ($_calls > $_expectedCalls)',

[Bob Nystrom, 2012/06/13 23:52:29]

Indent another 1.

[gram, 2012/06/14 00:50:58]

Done.

          '');
       _state = _UNCAUGHT_ERROR;
       return false;
     }
     return true;
   }
 }
 
 /**
  * Indicate that [callback] is expected to be called a [count] number of times
  * (by default 1). The unittest framework will wait for the callback to run the
  * specified [count] times before it continues with the following test.  Using
  * [_expectAsync] will also ensure that errors that occur within [callback] are
  * tracked and reported. [callback] should take between 0 and 4 positional
  * arguments (named arguments are not supported here).
  */
 Function _expectAsync(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke;
+  return new _SpreadArgsHelper.fixedCallCount(callback, count).invoke;
 }
 
 /**
  * Indicate that [callback] is expected to be called a [count] number of times
  * (by default 1). The unittest framework will wait for the callback to run the
  * specified [count] times before it continues with the following test.  Using
  * [expectAsync0] will also ensure that errors that occur within [callback] are
  * tracked and reported. [callback] should take 0 positional arguments (named
  * arguments are not supported).
  */
 // TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function expectAsync0(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke0;
+  return new _SpreadArgsHelper.fixedCallCount(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;
+  return new _SpreadArgsHelper.fixedCallCount(callback, count).invoke1;
 }
 
 /** 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;
+  return new _SpreadArgsHelper.fixedCallCount(callback, count).invoke2;
+}
+
+/**
+ * Indicate that [callback] is expected to be called until [isDone] returns
+ * true. The unittest framework check [isDone] after each callback and only

[Bob Nystrom, 2012/06/13 23:52:29]

"check" -> "checks"

[gram, 2012/06/14 00:50:58]

Done.

+ * when it returns true will it continue with the following test. Using
+ * [expectAsyncUntil] will also ensure that errors that occur within
+ * [callback] are tracked and reported. [callback] should take between 0 and
+ * 4 positional arguments (named arguments are not supported).
+ */
+Function expectAsyncUntil(Function callback, Function isDone) {

[Siggi Cherem (dart-lang), 2012/06/13 23:43:53]

make this private until issue 2706 gets fixed

[gram, 2012/06/14 00:50:58]

Done.

+  return new _SpreadArgsHelper.variableCallCount(callback, isDone).invoke;
+}
+
+/**
+ * Indicate that [callback] is expected to be called until [isDone] returns
+ * true. The unittest framework check [isDone] after each callback and only
+ * when it returns true will it continue with the following test. Using
+ * [expectAsyncUntil0] will also ensure that errors that occur within
+ * [callback] are tracked and reported. [callback] should take 0 positional
+ * arguments (named arguments are not supported).
+ */
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+Function expectAsyncUntil0(Function callback, Function isDone) {
+  return new _SpreadArgsHelper.variableCallCount(callback, isDone).invoke0;
+}
+
+/**
+ * Like [expectAsyncUntil0] but [callback] should take 1 positional argument.
+ */
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+Function expectAsyncUntil1(Function callback, Function isDone) {
+  return new _SpreadArgsHelper.variableCallCount(callback, isDone).invoke1;
+}
+
+/**
+ * Like [expectAsyncUntil0] but [callback] should take 2 positional arguments.
+ */
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+Function expectAsyncUntil2(Function callback, Function isDone) {
+  return new _SpreadArgsHelper.variableCallCount(callback, isDone).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()) {
   ensureInitialized();
 
   // Concatenate the new group.
   final oldGroup = _currentGroup;
   if (_currentGroup != '') {
     // Add a space.
     _currentGroup = '$_currentGroup $description';
   } else {
     // The first group.
     _currentGroup = description;
   }
 
   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() {
+void _handleAllCallbacksDone() {
   // 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 nextBatch(),
   // which is recursively invoked in the case of async tests that
   // run synchronously. Bad things can then happen.
   _defer(() {
     _callbacksCalled++;
     if (_currentTest < _tests.length) {
       final testCase = _tests[_currentTest];
@@ skipping 95 matching lines @@
  * 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.
  */
 _nextBatch() {
   while (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
     guardAsync(() {
       _callbacksCalled = 0;
       _state = _RUNNING_TEST;
-
       testCase.test();
 
       if (_state != _UNCAUGHT_ERROR) {
         if (testCase.callbacks == _callbacksCalled) {
           testCase.pass();
         }
       }
     });
 
     if (!testCase.isComplete && testCase.callbacks > 0) return;
@@ skipping 33 matching lines @@
   throw new ExpectException(message);
 }
 
 /**
  * Lazily initializes the test library if not already initialized.
  */
 ensureInitialized() {
   if (_state != _UNINITIALIZED) return;
 
   _tests = <TestCase>[];
+  _uncaughtErrorMessage = null;
+  _currentTest = 0;
   _currentGroup = '';
   _state = _READY;
   _testRunner = _nextBatch;
 
   if (_config == null) {
     _config = new Configuration();
   }
   _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();