pkg/unittest: much cleaner support for arbitrary args in expectAsync functions

pkg/unittest/lib/src/spread_args_helper.dart

 part of unittest;
 
+const _PLACE_HOLDER = const _ArgPlaceHolder();
+
+class _ArgPlaceHolder {
+  const _ArgPlaceHolder();
+}
+
 /** Simulates spread arguments using named arguments. */
 // TODO(sigmund): remove this class and simply use a closure with named
 // arguments (if still applicable).
-class _SpreadArgsHelper {
+class _SpreadArgsHelper implements Function {
   final Function callback;
   final int minExpectedCalls;
   final int maxExpectedCalls;
   final Function isDone;
   final String id;
   int actualCalls = 0;
   final TestCase testCase;
   bool complete;
 
   _SpreadArgsHelper(Function callback, int minExpected, int maxExpected,
-      Function isDone, String id)
+      String id, {bool isDone()})
       : this.callback = callback,
         minExpectedCalls = minExpected,
         maxExpectedCalls = (maxExpected == 0 && minExpected > 0)
             ? minExpected
             : maxExpected,
         this.isDone = isDone,
         this.testCase = currentTestCase,
         this.id = _makeCallbackId(id, callback) {
     ensureInitialized();
     if (testCase == null) {
@@ skipping 55 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() {
+  call([a0 = _PLACE_HOLDER, a1 = _PLACE_HOLDER, a2 = _PLACE_HOLDER,
+      a3 = _PLACE_HOLDER, a4 = _PLACE_HOLDER, a5 = _PLACE_HOLDER]) {
+
+    var args = [a0, a1, a2, a3, a4, a5];
+    args.removeWhere((a) => a == _PLACE_HOLDER);
+
     return _guardAsync(
         () {
           if (shouldCallBack()) {
-            return callback();
+            return Function.apply(callback, args);
           }
         },
         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);
   }
 
   _guardAsync(Function tryBody, Function finallyBody, TestCase testCase) {
     assert(testCase != null);
     try {
       return tryBody();
     } catch (e, trace) {
       _registerException(testCase, e, trace);
     } finally {
       if (finallyBody != null) finallyBody();
     }
   }
 }