pkg/unittest: deprecate expectAsyncN and expectAsyncUntilN

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 295 matching lines @@
     test(spec, body);
   } finally {
     --_soloNestingLevel;
   }
 }
 
 /**
  * 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
+ * [expectAsync] 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.
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsync0(Function callback,
+Function expectAsync(Function callback,
                      {int count: 1, int max: 0, String id}) {
-  return new _SpreadArgsHelper(callback, count, max, null, id).invoke0;
+  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:
+      throw new StateError('Should never get here');

[Siggi Cherem (dart-lang), 2014/02/07 20:34:08]

let's change the message to help users know why :)

how about:
"Couldn't determine total number of arguments for callback. expectAsync only
supports functions that take 0, 1, or 2 arguments.

[kevmoo, 2014/02/07 20:45:27]

Done.

+  }
 }
 
-/** 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 expectAsync0(Function callback,
+                     {int count: 1, int max: 0, String id}) =>
+    expectAsync(callback, count: count, max: max, id: id);
+
+/**
+ * *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
+ * [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).
  */
-// 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}) {
+  var minArgs = _minArgs(callback);
 
-/**
- * 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, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, isDone, id).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, {String id}) {
-  return new _SpreadArgsHelper(callback, 0, -1, isDone, id).invoke2;
+  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:
+      throw new StateError('Should never get here');

[Siggi Cherem (dart-lang), 2014/02/07 20:34:08]

same here

[kevmoo, 2014/02/07 20:45:27]

Done.

+  }
 }
 
 /**
  * *Deprecated*
+ *
+ * Use [expectAsyncUntil] instead.
+ */
+@deprecated
+Function expectAsyncUntil0(Function callback, Function isDone, {String id}) =>
+    expectAsyncUntil(callback, isDone, id: id);
+
+/**
+ * *Deprecated*
+ *
+ * Use [expectAsyncUntil] instead.
+ */
+@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);
+
+/**
+ * *Deprecated*
  *
  * All tests are now run an isolated [Zone].
  *
  * You can safely remove calls to this method.
  */
 @deprecated
 Function protectAsync0(Function callback, {String id}) {
   return callback;
 }
 
@@ skipping 237 matching lines @@
 void ensureInitialized() {
   _ensureInitialized(true);
 }
 
 void _ensureInitialized(bool configAutoStart) {
   if (_initialized) {
     return;
   }
   _initialized = true;
   // Hook our async guard into the matcher library.
-  wrapAsync = (f, [id]) => expectAsync1(f, id: id);
+  wrapAsync = (f, [id]) => expectAsync(f, id: id);
 
   _uncaughtErrorMessage = null;
 
   unittestConfiguration.onInit();
 
   if (configAutoStart && _config.autoStart) {
     // Immediately queue the suite up. It will run after a timeout (i.e. after
     // main() has returned).
     scheduleMicrotask(runTests);
   }
@@ skipping 64 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.');

[Siggi Cherem (dart-lang), 2014/02/07 20:34:08]

ah - I see, then you can keep the other state error, but maybe add a comment
saying that _minArgs will throw and that's why it is a state error.

[kevmoo, 2014/02/07 20:45:27]

Done.

+}