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

lib/unittest/unittest.dart

 // Copyright (c) 2011, 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.
 
 /**
  * A library for writing dart unit tests.
  *
  * ##Concepts##
  *
  *  * Tests: Tests are specified via the top-level function [test], they can be
@@ skipping 46 matching lines @@
  *         });
  *       });
  *       group('group B', () {
  *         test('this B.1', () {
  *           int x = 2 + 3;
  *           expect(x).equals(5);
  *         });
  *       });
  *     }
  *
- * 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(() {
+ *       // use [asyncTest], indicate the expected number of callbacks:
+ *       asyncTest('this is a test', 1, () {
+ *         window.setTimeout(() {
+ *           int x = 2 + 3;
+ *           expect(x).equals(5);
+ *           // invoke [callbackDone] at the end of the callback.
+ *           callbackDone();
+ *         }, 0);
+ *       });
+ *     }
+ *
+ * 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('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);
  *       });
- *
- *       test('calllback is executed twice', () {
- *         var callback = expectAsync0(() {
- *           int x = 2 + 3;
- *           expect(x).equals(5);
- *         }, count: 2); // <-- we can indicate multiplicity to [expectAsync0]
- *         window.setTimeout(callback, 0);
- *         window.setTimeout(callback, 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).
- *
- *     #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();
- *         }), 0);
- *       });
- *
  */
 #library('unittest');
 
 #import('dart:isolate');
 
 #source('config.dart');
 #source('expectation.dart');
 #source('test_case.dart');
 
 /** [Configuration] used by the unittest library. */
@@ skipping 30 matching lines @@
 final _RUNNING_TEST  = 2;
 
 /**
  * Whether an undetected error occurred while running the last test. These
  * errors are commonly caused by DOM callbacks that were not guarded in a
  * try-catch block.
  */
 final _UNCAUGHT_ERROR = 3;
 
 int _state = _UNINITIALIZED;
-String _uncaughtErrorMessage = null;
 
 final _PASS  = 'pass';
 final _FAIL  = 'fail';
 final _ERROR = 'error';
 
 /** Creates an expectation for the given value. */
 Expectation expect(value) => new Expectation(value);
 
 /** Evaluates the given function and validates that it throws an exception. */
 void expectThrow(function) {
   bool threw = false;
   try {
     function();
   } catch (var e) {
     threw = true;
   }
   Expect.equals(true, threw, 'Expected exception but none was thrown.');
 }
 
 /**
  * Creates a new test case with the given description and body. The
  * description will include the descriptions of any surrounding group()
  * calls.
  */
 void test(String spec, TestFunction body) {
-  ensureInitialized();
+  _ensureInitialized();
 
   _tests.add(new TestCase(_tests.length + 1, _fullSpec(spec), body, 0));
 }
 
 /**
  * Creates a new async test case with the given description and body. The
  * description will include the descriptions of any surrounding group()
  * calls.
  */
 // 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);
   _tests.add(testCase);
 
   if (callbacks < 1) {
     testCase.error(
         'Async tests must wait for at least one callback ', '');
   }
 }
 
-/** 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).
+ * 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.
  */
-Function _expectAsync(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke;
+// TODO(sigmund): expose this functionality
+Function _later0(Function callback) {
+  Expect.isTrue(_currentTest < _tests.length);
+  var testCase = _tests[_currentTest];
+  testCase.callbacks++;
+  return () {
+    _guard(() => callback(), callbackDone);
+  };
+}
+
+// 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);
+  };
+}
+
+// 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);
+  };
 }
 
 /**
- * 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).
- */
-// TODO(sigmund): deprecate this API when issue 2706 is fixed.
-Function expectAsync0(Function callback, [int count = 1]) {
-  return new _SpreadArgsHelper(callback, count).invoke0;
-}
-
-/** 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;
-}
-
-/** 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;
-}
-
-/**
  * 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();
+  _ensureInitialized();
 
   // Concatenate the new group.
   final oldGroup = _currentGroup;
   if (_currentGroup != '') {
     // Add a space.
     _currentGroup = '$_currentGroup $description';
   } else {
     // The first group.
     _currentGroup = description;
   }
 
   try {
     body();
   } finally {
     // Now that the group is over, restore the previous one.
     _currentGroup = oldGroup;
   }
 }
 
 /** 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);
     _state = _UNCAUGHT_ERROR;
     if (testCase.callbacks > 0) {
       _currentTest++;
       _testRunner();
     }
-  } else {
-    _uncaughtErrorMessage = "$msg: $trace";
   }
 }
 
 /** Runs [callback] at the end of the event loop. */
 _defer(void callback()) {
   // Exploit isolate ports as a platform-independent mechanism to queue a
   // message at the end of the event loop.
   // TODO(sigmund): expose this functionality somewhere in our libraries.
   final port = new ReceivePort();
   port.receive((msg, reply) {
@@ skipping 11 matching lines @@
     assert (_currentTest == 0);
     _testRunner();
   });
 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, update
  * 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;
     if (finallyBody != null) finallyBody();
   }
 }
 
 /**
  * Runs a batch of tests, yielding whenever an asynchronous test starts
  * running. Tests will resume executing when such asynchronous test calls
  * [done] or if it fails with an exception.
  */
 _nextBatch() {
   while (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
+
     _guard(() {
       _callbacksCalled = 0;
       _state = _RUNNING_TEST;
 
       testCase.test();
 
       if (_state != _UNCAUGHT_ERROR) {
         if (testCase.callbacks == _callbacksCalled) {
           testCase.pass();
         }
@@ skipping 17 matching lines @@
   int testsErrors_ = 0;
 
   for (TestCase t in _tests) {
     switch (t.result) {
       case _PASS:  testsPassed_++; break;
       case _FAIL:  testsFailed_++; break;
       case _ERROR: testsErrors_++; break;
     }
   }
 
-  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests,
-      _uncaughtErrorMessage);
+  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests);
 }
 
 String _fullSpec(String spec) {
   if (spec === null) return '$_currentGroup';
   return _currentGroup != '' ? '$_currentGroup $spec' : spec;
 }
 
 /**
  * Lazily initializes the test library if not already initialized.
  */
-ensureInitialized() {
+_ensureInitialized() {
   if (_state != _UNINITIALIZED) return;
 
   _tests = <TestCase>[];
   _currentGroup = '';
   _state = _READY;
   _testRunner = _nextBatch;
 
   if (_config == null) {
     _config = new Configuration();
   }
   _config.onInit();
 
   // Immediately queue the suite up. It will run after a timeout (i.e. after
   // main() has returned).
   _defer(_runTests);
 }
 
 /** Signature for a test function. */
 typedef void TestFunction();