Revert https://code.google.com/p/dart/source/detail?r=33346

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.
 
 /**
  * Support for writing Dart unit tests.
  *
  * For information on installing and importing this library, see the
  * [unittest package on pub.dartlang.org]
  * (http://pub.dartlang.org/packages/unittest).
@@ skipping 307 matching lines @@
  * arguments are not supported). [id] can be used to provide more
  * descriptive error messages if the callback is called more often than
  * expected. [max] can be used to specify an upper bound on the number of
  * calls; if this is exceeded the test will fail (or be marked as in error if
  * it was already complete). A value of 0 for [max] (the default) will set
  * the upper bound to the same value as [count]; i.e. the callback should be
  * called exactly [count] times. A value of -1 for [max] will mean no upper
  * bound.
  */
 Function expectAsync(Function callback,
-    {int count: 1, int max: 0, String id}) =>
-  new _SpreadArgsHelper(callback, count, max, id);
+                     {int count: 1, int max: 0, String id}) {
+  var minArgs = _minArgs(callback);
+
+  switch(minArgs) {
+    case 0:
+      return new _SpreadArgsHelper(callback, count, max, null, id).invoke0;
+    case 1:
+      return new _SpreadArgsHelper(callback, count, max, null, id).invoke1;
+    case 2:
+      return new _SpreadArgsHelper(callback, count, max, null, id).invoke2;
+    default:
+      // _minArgs throws an argument exception if the arg count is > 2.
+      // this is just for paranoia
+      throw new StateError('Should never get here');
+  }
+}
 
 /**
  * *Deprecated*
  *
  * Use [expectAsync] instead.
  */
 @deprecated
 Function expectAsync0(Function callback,
                      {int count: 1, int max: 0, String id}) =>
     expectAsync(callback, count: count, max: max, id: id);
@@ skipping 21 matching lines @@
 /**
  * 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
  * [expectAsyncUntil] will also ensure that errors that occur within
  * [callback] are tracked and reported. [callback] should take 0 positional
  * arguments (named arguments are not supported). [id] can be used to
  * identify the callback in error messages (for example if it is called
  * after the test case is complete).
  */
-Function expectAsyncUntil(Function callback, bool isDone(), {String id}) =>
-    new _SpreadArgsHelper(callback, 0, -1, id, isDone: isDone);
+Function expectAsyncUntil(Function callback, Function isDone, {String id}) {
+  var minArgs = _minArgs(callback);
+
+  switch(minArgs) {
+    case 0:
+      return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke0;
+    case 1:
+      return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke1;
+    case 2:
+      return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke2;
+    default:
+      // _minArgs throws an argument exception if the arg count is > 2.
+      // this is just for paranoia
+      throw new StateError('Should never get here');
+  }
+}
 
 /**
  * *Deprecated*
  *
  * Use [expectAsyncUntil] instead.
  */
 @deprecated
 Function expectAsyncUntil0(Function callback, Function isDone, {String id}) =>
     expectAsyncUntil(callback, isDone, id: id);
 
@@ skipping 352 matching lines @@
 
   if (!filterStacks) 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);
 }
+
+typedef _Func0();
+typedef _Func1(a);
+typedef _Func2(a, b);
+
+/**
+ * Throws an [ArgumentError] if the callback has more than 2 required arguments.
+ */
+int _minArgs(Function callback) {
+  if (callback is _Func0) return 0;
+  if (callback is _Func1) return 1;
+  if (callback is _Func2) return 2;
+  throw new ArgumentError(
+      'The callback argument has more than 2 required arguments.');
+}