Fixed expect, protect methods to allow any set of arguments

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 430 matching lines @@
       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;
       testCase._markCallbackComplete();
     }
   }
 
-  invoke0() {
+  /**
+   * Using [noSuchMethod] to handle the invocation of [call].
+   *
+   * This allows direct access to the arguments via [Invocation], which are
+   * passed to the original callback.
+   */
+  dynamic noSuchMethod(Invocation invocation) {
+    if (invocation.memberName != #call) return super.noSuchMethod(invocation);
+
     return _guardAsync(
         () {
           if (shouldCallBack()) {
-            return callback();
+            return Function.apply(callback, invocation.positionalArguments,
+                invocation.namedArguments);
           }
         },
         after, testCase);
   }
 
-  invoke1(arg1) {
-    return _guardAsync(
-        () {
-          if (shouldCallBack()) {
-            return callback(arg1);
-          }
-        },
-        after, testCase);
-  }
-
-  invoke2(arg1, arg2) {
-    return _guardAsync(
-        () {
-          if (shouldCallBack()) {
-            return callback(arg1, arg2);
-          }
-        },
-        after, testCase);
-  }
+  /**
+   * Eliminates type warnings since this class does not directly expose the
+   * [call] method -- causing compliants that it is not a valid [Function].
+   */
+  // TODO(kevmoo): consider implementing Function and flagging class with @proxy
+  Function get asFunction => (this as dynamic);
 }
 
 /**
  * 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
+ * (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). [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.
+ * [expectAsync] will also ensure that errors that occur within [callback] are
+ * tracked and reported.
+ *
+ * [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.
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+Function expectAsync(Function callback,
+                     {int count: 1, int max: 0, String id}) =>
+  new _SpreadArgsHelper(callback, count, max, null, id).asFunction;
+
+/**
+ * *DEPRECATED*: use [expectAsync] instead.
+ **/
+@deprecated
 Function expectAsync0(Function callback,
-                     {int count: 1, int max: 0, String id}) {
-  return new _SpreadArgsHelper(callback, count, max, null, id).invoke0;
-}
+                     {int count: 1, int max: 0, String id}) =>
+                         expectAsync(callback, count: count, max: max, id: id);
 
-/** Like [expectAsync0] but [callback] should take 1 positional argument. */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+/**
+ * *DEPRECATED*: use [expectAsync] instead.
+ **/
+@deprecated
 Function expectAsync1(Function callback,
-                     {int count: 1, int max: 0, String id}) {
-  return new _SpreadArgsHelper(callback, count, max, null, id).invoke1;
-}
+                     {int count: 1, int max: 0, String id}) =>
+                         expectAsync(callback, count: count, max: max, id: id);
 
-/** Like [expectAsync0] but [callback] should take 2 positional arguments. */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
+/**
+ * *DEPRECATED*: use [expectAsync] instead.
+ **/
+@deprecated
 Function expectAsync2(Function callback,
-                     {int count: 1, int max: 0, String id}) {
-  return new _SpreadArgsHelper(callback, count, max, null, id).invoke2;
-}
+                     {int count: 1, int max: 0, String id}) =>
+                         expectAsync(callback, count: count, max: max, id: id);
 
 /**
  * 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). [id] can be used to
- * identify the callback in error messages (for example if it is called
- * after the test case is complete).
+ * 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.
+ *
+ * [id] can be used to identify the callback in error messages (for example if
+ * it is called after the test case is complete).
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsyncUntil0(Function callback, Function isDone, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke0;
-}
+Function expectAsyncUntil(Function callback, Function isDone, {String id}) =>
+  new _SpreadArgsHelper(callback, 0, -1, isDone, id).asFunction;
 
 /**
- * Like [expectAsyncUntil0] but [callback] should take 1 positional argument.
+ * *DEPRECATED*: Use [expectAsyncUntil] instead.
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsyncUntil1(Function callback, Function isDone, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke1;
-}
+@deprecated
+Function expectAsyncUntil0(Function callback, Function isDone, {String id}) =>
+    expectAsyncUntil(callback, isDone, id: id);
 
 /**
- * Like [expectAsyncUntil0] but [callback] should take 2 positional arguments.
+ * *DEPRECATED*: Use [expectAsyncUntil] instead.
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsyncUntil2(Function callback, Function isDone, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke2;
-}
+@deprecated
+Function expectAsyncUntil1(Function callback, Function isDone, {String id})  =>
+    expectAsyncUntil(callback, isDone, id: id);
+
+/**
+ * *DEPRECATED*: Use [expectAsyncUntil] instead.
+ */
+@deprecated
+Function expectAsyncUntil2(Function callback, Function isDone, {String id})  =>
+    expectAsyncUntil(callback, isDone, id: id);
 
 /**
  * Wraps the [callback] in a new function and returns that function. The new
  * function will be able to handle exceptions by directing them to the correct
- * test. This is thus similar to expectAsync0. Use it to wrap any callbacks that
- * might optionally be called but may never be called during the test.
- * [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).
+ * test. This is thus similar to [expectAsync]. Use it to wrap any callbacks
+ * that might optionally be called but may never be called during the test.
+ *
+ * [id] can be used to identify the callback in error messages (for example if
+ * it is called after the test case is complete).
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function protectAsync0(Function callback, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, null, id).invoke0;
-}
+Function protectAsync(Function callback, {String id}) =>
+  new _SpreadArgsHelper(callback, 0, -1, null, id).asFunction;
 
 /**
- * Like [protectAsync0] but [callback] should take 1 positional argument.
- */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function protectAsync1(Function callback, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, null, id).invoke1;
-}
+ * *DEPRECATED*: use [protectAsync] instead.
+ **/
+@deprecated
+Function protectAsync0(Function callback, {String id}) =>
+    protectAsync(callback, id: id);
 
 /**
- * Like [protectAsync0] but [callback] should take 2 positional arguments.
- */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function protectAsync2(Function callback, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, null, id).invoke2;
-}
+ * *DEPRECATED*: use [protectAsync] instead.
+ **/
+@deprecated
+Function protectAsync1(Function callback, {String id}) =>
+    protectAsync(callback, id: id);
+
+/**
+ * *DEPRECATED*: use [protectAsync] instead.
+ **/
+@deprecated
+Function protectAsync2(Function callback, {String id})  =>
+    protectAsync(callback, id: id);
 
 /**
  * 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();
   _currentContext = new _GroupContext(_currentContext, description);
   try {
     body();
@@ skipping 285 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);
 }