Revert "unittest step 3 and 4: remove TestFramework.dart, make test.dart use"

lib/unittest/unittest.dart

Index: lib/unittest/unittest.dart
diff --git a/lib/unittest/unittest.dart b/lib/unittest/unittest.dart
index c3df29654fd0eca65c32be3767778c9fedb0c17d..8d4d0171dd143217f092d02d7ffbc71eef569439 100644
--- a/lib/unittest/unittest.dart
+++ b/lib/unittest/unittest.dart
@@ -64,58 +64,35 @@
  *       });
  *     }
  *
- * Asynchronous tests: if callbacks expect between 0 and 2 positional arguments.
+ * Asynchronous tests: under the current API (soon to be deprecated):
  *
  *     #import('path-to-dart/lib/unittest/unitest.dart');
  *     #import('dart:dom');
  *     main() {
- *       test('calllback is executed once', () {
- *         // wrap the callback of an asynchronous call with [expectAsync0] if
- *         // the callback takes 0 arguments...
- *         window.setTimeout(expectAsync0(() {
- *           int x = 2 + 3;
- *           expect(x).equals(5);
- *         }), 0);
- *       });
- *
- *       test('calllback is executed twice', () {
- *         var callback = expectAsync0(() {
+ *       // use [asyncTest], indicate the expected number of callbacks:
+ *       asyncTest('this is a test', 1, () {
+ *         window.setTimeout(() {
  *           int x = 2 + 3;
  *           expect(x).equals(5);
- *         }, count: 2); // <-- we can indicate multiplicity to [expectAsync0]
- *         window.setTimeout(callback, 0);
- *         window.setTimeout(callback, 0);
+ *           // invoke [callbackDone] at the end of the callback.
+ *           callbackDone();
+ *         }, 0);
  *       });
  *     }
  *
- * Note: due to some language limitations we have to use different functions
- * depending on the number of positional arguments of the callback. In the
- * future, we plan to expose a single `expectAsync` function that can be used
- * regardless of the number of positional arguments. This requires new langauge
- * features or fixes to the current spec (e.g. see dartbug.com/2706).
- *
- * Meanwhile, we plan to add this alternative API for callbacks of more than 2
- * arguments or that take named parameters. (this is not implemented yet,
- * but will be coming here soon).
+ * We plan to replace this with a different API, one API we are considering is:
  *
  *     #import('path-to-dart/lib/unittest/unitest.dart');
  *     #import('dart:dom');
  *     main() {
- *       test('calllback is executed', () {
- *         // indicate ahead of time that an async callback is expected.
- *         var async = startAsync();
- *         window.setTimeout(() {
- *           // Guard the body of the callback, so errors are propagated
- *           // correctly
- *           guardAsync(() {
- *             int x = 2 + 3;
- *             expect(x).equals(5);
- *           });
- *           // indicate that the asynchronous callback was invoked.
- *           async.complete();
+ *       test('this is a test', () {
+ *         // wrap the callback of an asynchronous call with [later]
+ *         window.setTimeout(later(() {
+ *           int x = 2 + 3;
+ *           expect(x).equals(5);
  *         }), 0);
  *       });
- *
+ *     }
  */
 #library('unittest');
 
@@ -166,7 +143,6 @@ final _RUNNING_TEST  = 2;
 final _UNCAUGHT_ERROR = 3;
 
 int _state = _UNINITIALIZED;
-String _uncaughtErrorMessage = null;
 
 final _PASS  = 'pass';
 final _FAIL  = 'fail';
@@ -192,7 +168,7 @@ void expectThrow(function) {
  * calls.
  */
 void test(String spec, TestFunction body) {
-  ensureInitialized();
+  _ensureInitialized();
 
   _tests.add(new TestCase(_tests.length + 1, _fullSpec(spec), body, 0));
 }
@@ -204,7 +180,7 @@ void test(String spec, TestFunction body) {
  */
 // TODO(sigmund): deprecate this API
 void asyncTest(String spec, int callbacks, TestFunction body) {
-  ensureInitialized();
+  _ensureInitialized();
 
   final testCase = new TestCase(
       _tests.length + 1, _fullSpec(spec), body, callbacks);
@@ -216,121 +192,44 @@ void asyncTest(String spec, int callbacks, TestFunction body) {
   }
 }
 
-/** Sentinel value for [_SpreadArgsHelper]. */
-class _Sentinel {
-  const _Sentinel();
-}
-
-// 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) {
-    Expect.isTrue(_currentTest < _tests.length);
-    testCase = _tests[_currentTest];
-    testCase.callbacks++;
-  }
-
-  invoke([arg0 = _sentinel, arg1 = _sentinel, arg2 = _sentinel,
-          arg3 = _sentinel, arg4 = _sentinel]) {
-    return _guard(() {
-      if (!_incrementCall()) {
-        return;
-      } else if (arg0 == _sentinel) {
-        return callback();
-      } else if (arg1 == _sentinel) {
-        return callback(arg0);
-      } else if (arg2 == _sentinel) {
-        return callback(arg0, arg1);
-      } else if (arg3 == _sentinel) {
-        return callback(arg0, arg1, arg2);
-      } else if (arg4 == _sentinel) {
-        return callback(arg0, arg1, arg2, arg3);
-      } else {
-        testCase.error(
-           'unittest lib does not support callbacks with more than 4 arguments',
-           '');
-        _state = _UNCAUGHT_ERROR;
-      }
-    }, () { if (calls == expectedCalls) callbackDone(); });
-  }
-
-  invoke0() {
-    return _guard(
-        () => _incrementCall() ? callback() : null,
-        () { if (calls == expectedCalls) callbackDone(); });
-  }
-
-  invoke1(arg1) {
-    return _guard(
-        () => _incrementCall() ? callback(arg1) : null,
-        () { if (calls == expectedCalls) callbackDone(); });
-  }
-
-  invoke2(arg1, arg2) {
-    return _guard(
-        () => _incrementCall() ? callback(arg1, arg2) : null,
-        () { if (calls == expectedCalls) callbackDone(); });
-  }
-
-  /** Returns false if we exceded the number of expected calls. */
-  bool _incrementCall() {
-    calls++;
-    if (calls > expectedCalls) {
-      testCase.error(
-         'Callback called more times than expected ($expectedCalls)',
-         '');
-      _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;
-}
-
 /**
- * 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).
+ * Indicate to the unittest framework that a 0-argument callback is expected.
+ *
+ * The framework will wait for the callback to run before it continues with the
+ * following test. The callback must excute once and only once. Using [later]
+ * will also ensure that errors that occur within the callback are tracked and
+ * reported by the unittest framework.
  */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsync0(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke0;
+// TODO(sigmund): expose this functionality
+Function _later0(Function callback) {
+  Expect.isTrue(_currentTest < _tests.length);
+  var testCase = _tests[_currentTest];
+  testCase.callbacks++;
+  return () {
+    _guard(() => callback(), callbackDone);
+  };
 }
 
-/** 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;
+// TODO(sigmund): expose this functionality
+/** Like [_later0] but expecting a callback with 1 argument. */
+Function _later1(Function callback) {
+  Expect.isTrue(_currentTest < _tests.length);
+  var testCase = _tests[_currentTest];
+  testCase.callbacks++;
+  return (arg0) {
+    _guard(() => callback(arg0), callbackDone);
+  };
 }
 
-/** Like [expectAsync0] but [callback] should take 1 positional argument. */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsync2(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke2;
+// TODO(sigmund): expose this functionality
+/** Like [_later0] but expecting a callback with 2 arguments. */
+Function _later2(Function callback) {
+  Expect.isTrue(_currentTest < _tests.length);
+  var testCase = _tests[_currentTest];
+  testCase.callbacks++;
+  return (arg0, arg1) {
+    _guard(() => callback(arg0, arg1), callbackDone);
+  };
 }
 
 /**
@@ -338,7 +237,7 @@ Function expectAsync2(Function callback, [int count = 1]) {
  * body of the function passed to this will inherit this group's description.
  */
 void group(String description, void body()) {
-  ensureInitialized();
+  _ensureInitialized();
 
   // Concatenate the new group.
   final oldGroup = _currentGroup;
@@ -361,25 +260,22 @@ void group(String description, void body()) {
 /** Called by subclasses to indicate that an asynchronous test completed. */
 void callbackDone() {
   _callbacksCalled++;
-  if (_currentTest < _tests.length) {
-    final testCase = _tests[_currentTest];
-    if (_callbacksCalled > testCase.callbacks) {
-      final expected = testCase.callbacks;
-      testCase.error(
-          'More calls to callbackDone() than expected. '
-          'Actual: ${_callbacksCalled}, expected: ${expected}', '');
-      _state = _UNCAUGHT_ERROR;
-    } else if ((_callbacksCalled == testCase.callbacks) &&
-        (_state != _RUNNING_TEST)) {
-      if (testCase.result == null) testCase.pass();
-      _currentTest++;
-      _testRunner();
-    }
+  final testCase = _tests[_currentTest];
+  if (_callbacksCalled > testCase.callbacks) {
+    final expected = testCase.callbacks;
+    testCase.error(
+        'More calls to callbackDone() than expected. '
+        'Actual: ${_callbacksCalled}, expected: ${expected}', '');
+    _state = _UNCAUGHT_ERROR;
+  } else if ((_callbacksCalled == testCase.callbacks) &&
+      (_state != _RUNNING_TEST)) {
+    if (testCase.result == null) testCase.pass();
+    _currentTest++;
+    _testRunner();
   }
 }
 
-/** Menchanism to notify that an error was caught outside of this library. */
-void reportTestError(String msg, String trace) {
+void notifyError(String msg, String trace) {
  if (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
     testCase.error(msg, trace);
@@ -388,8 +284,6 @@ void reportTestError(String msg, String trace) {
       _currentTest++;
       _testRunner();
     }
-  } else {
-    _uncaughtErrorMessage = "$msg: $trace";
   }
 }
 
@@ -421,15 +315,18 @@ _runTests() {
  * the [_currentTest] status accordingly.
  */
 _guard(tryBody, [finallyBody]) {
+  final testCase = _tests[_currentTest];
   try {
-    return tryBody();
+    tryBody();
   } catch (ExpectException e, var trace) {
     if (_state != _UNCAUGHT_ERROR) {
-      _tests[_currentTest].fail(e.message, trace.toString());
+      //TODO(pquitslund) remove guard once dartc reliably propagates traces
+      testCase.fail(e.message, trace == null ? '' : trace.toString());
     }
   } catch (var e, var trace) {
     if (_state != _UNCAUGHT_ERROR) {
-      _tests[_currentTest].error('Caught $e', trace.toString());
+      //TODO(pquitslund) remove guard once dartc reliably propagates traces
+      testCase.error('Caught ${e}', trace == null ? '' : trace.toString());
     }
   } finally {
     _state = _READY;
@@ -445,6 +342,7 @@ _guard(tryBody, [finallyBody]) {
 _nextBatch() {
   while (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
+
     _guard(() {
       _callbacksCalled = 0;
       _state = _RUNNING_TEST;
@@ -482,8 +380,7 @@ _completeTests() {
     }
   }
 
-  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests,
-      _uncaughtErrorMessage);
+  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests);
 }
 
 String _fullSpec(String spec) {
@@ -494,7 +391,7 @@ String _fullSpec(String spec) {
 /**
  * Lazily initializes the test library if not already initialized.
  */
-ensureInitialized() {
+_ensureInitialized() {
   if (_state != _UNINITIALIZED) return;
 
   _tests = <TestCase>[];