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 125 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 ', '');
   }
 }
 
 /**
  * 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): expose this functionality
-Function _later0(Function callback) {
+Function later0(Function callback) {

[Bob Nystrom, 2012/04/20 22:31:36]

I remember discussing it, but I don't remember the details. Is there a way we
can unify these into a single method using named optional arguments? The numbers
really bug me.

I'm also not sure about "later". It doesn't convey much of anything to me. Maybe
"testCallback"?

[Siggi Cherem (dart-lang), 2012/04/21 00:03:43]

I tried the approach that conflates them in a single method (simulating spread
args), but that trick doesn't works in frog, that's why I removed it. 

This trick:
later(f) {
 ...
 return ([a1=_def, a2=_def, ...]) { 
    ... // invoke f with correct num of args
 };
}

breaks because frog can't handle named arguments in closures (bug 282).

This trick breaks because frog doesn't keep optional argument information on
bound functions (bug 854). class _Helper {
  Function f;
  _Helper(this.f);
  invoke ([a1=_def, a2=_def, ...]) { 
    ... // invoke f with correct num of args
  }
}

later(f) {
 ...
 return new _Helper(f).invoke;
}

I added a TODO here to improve the API once they are fixed (or when we move to
use dart2js). I will take a closer look at 854. It might have an easy fix.
I want something that reads nicely, in the same way as 'expect' reads nice. What
about 'runsLater'? (or thinking of the later tests maybe 'runsOnce' and
'runsAtLeastOnce'?

test("timeout is called", () {
  window.setTimeout(runsLater(() { ... }), 0);
}

   Expect.isTrue(_currentTest < _tests.length);
   var testCase = _tests[_currentTest];
   testCase.callbacks++;
   return () {
     _guard(() => callback(), callbackDone);
   };
 }
 
 // TODO(sigmund): expose this functionality

[Emily Fortuna, 2012/04/20 20:06:19]

Comment obsolete now?

[Siggi Cherem (dart-lang), 2012/04/21 00:03:43]

Done.

-/** Like [_later0] but expecting a callback with 1 argument. */
-Function _later1(Function callback) {
+/** Like [later0] but expecting a callback with 1 argument. */
+Function later1(Function callback) {

[Emily Fortuna, 2012/04/20 20:06:19]

I'm not thrilled with the names of these functions, but I don't have any better
ideas outside of later1Arg, etc so we can keep them as is.

[Siggi Cherem (dart-lang), 2012/04/21 00:03:43]

I'm not thrilled either. There is a way to eliminate the 0/1/2, but it depends
on a feature that is not yet implemented in frog/dart2js

   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) {
+/** 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);
   };
 }
 
 /**
  * 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;
   }
@@ skipping 17 matching lines @@
         '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. */

[Bob Nystrom, 2012/04/20 22:31:36]

Should this even be public?

[Siggi Cherem (dart-lang), 2012/04/21 00:03:43]

Yes - we need it to be public so that unittest can be used by html_config (to
call it on window.onerror) and by test.dart (to call it when errors occur at the
top-level main method). 

[Bob Nystrom, 2012/04/23 17:34:07]

In that case, can we rename it something a little clearer? "notify" reads
strangely to me. How about "reportTestError"?

 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 76 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);
+  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests,
+      _uncaughtErrorMessage);
 }
 
 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();