Reverting 32284 - unittest using zones - investigating breaks in html

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 281 matching lines @@
     _testCases.clear();
   }
   ++_soloNestingLevel;
   try {
     test(spec, body);
   } finally {
     --_soloNestingLevel;
   }
 }
 
+/** Sentinel value for [_SpreadArgsHelper]. */
+class _Sentinel {
+  const _Sentinel();
+}
+
 /**
  * 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). [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
@@ skipping 47 matching lines @@
 
 /**
  * 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;
 }
 
 /**
- * *Deprecated*
- *
- * All tests are now run an isolated [Zone].
- *
- * You can safely remove calls to this method.
+ * Wraps the [callback] in a new function and returns that function. The new
+ * function will be able to handle exceptions by directing them to the correct
+ * test. This is thus similar to expectAsync0. Use it to wrap any callbacks that
+ * might optionally be called but may never be called during the test.
+ * [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).
  */
-@deprecated
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function protectAsync0(Function callback, {String id}) {
-  return callback;
+  return new _SpreadArgsHelper(callback, 0, -1, null, id).invoke0;
 }
 
 /**
- * *Deprecated*
- *
- * All tests are now run an isolated [Zone].
- *
- * You can safely remove calls to this method.
+ * Like [protectAsync0] but [callback] should take 1 positional argument.
  */
-@deprecated
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function protectAsync1(Function callback, {String id}) {
-  return callback;
+  return new _SpreadArgsHelper(callback, 0, -1, null, id).invoke1;
 }
 
 /**
- * *Deprecated*
- *
- * All tests are now run an isolated [Zone].
- *
- * You can safely remove calls to this method.
+ * Like [protectAsync0] but [callback] should take 2 positional arguments.
  */
-@deprecated
+// TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function protectAsync2(Function callback, {String id}) {
-  return callback;
+  return new _SpreadArgsHelper(callback, 0, -1, null, id).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();
   _requireNotRunning();
   _currentContext = new _GroupContext(_currentContext, description);
@@ skipping 65 matching lines @@
 void handleExternalError(e, String message, [stack]) {
   var msg = '$message\nCaught $e';
 
   if (currentTestCase != null) {
     currentTestCase._error(msg, stack);
   } else {
     _uncaughtErrorMessage = "$msg: $stack";
   }
 }
 
+void rerunTests() {
+  _uncaughtErrorMessage = null;
+  _initialized = true; // We don't want to reset the test array.
+  runTests();
+}
+
 /**
  * Filter the tests. [testFilter] can be a [RegExp], a [String] or a
  * predicate function. This is different to enabling/disabling tests
  * in that it removes the tests completely.
  */
 void filterTests(testFilter) {
   var filterFunction;
   if (testFilter is String) {
     RegExp re = new RegExp(testFilter);
     filterFunction = (t) => re.hasMatch(t.description);
   } else if (testFilter is RegExp) {
     filterFunction = (t) => testFilter.hasMatch(t.description);
   } else if (testFilter is Function) {
     filterFunction = testFilter;
   }
   _testCases.retainWhere(filterFunction);
 }
 
 /** Runs all queued tests, one at a time. */
 void runTests() {
   _requireNotRunning();
   _ensureInitialized(false);
   _currentTestCaseIndex = 0;
   _config.onStart();
   _runTest();
 }
 
 /**
- * *Deprecated*
+ * Run [tryBody] guarded in a try-catch block. If an exception is thrown, it is
+ * passed to the corresponding test.
  *
- * All tests are now run an isolated [Zone].
- *
- * You can safely remove calls to this method.
+ * The value returned by [tryBody] (if any) is returned by [guardAsync].
  */
-@deprecated
 guardAsync(Function tryBody) {
-  return tryBody();
+  return _guardAsync(tryBody, null, currentTestCase);
+}
+
+_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();
+  }
 }
 
 /**
  * Registers that an exception was caught for the current test.
  */
 void registerException(e, [trace]) {
   _registerException(currentTestCase, e, trace);
 }
 
 /**
@@ skipping 10 matching lines @@
 
 /**
  * Runs the next test.
  */
 void _runTest() {
   if (_currentTestCaseIndex >= testCases.length) {
     assert(_currentTestCaseIndex == testCases.length);
     _completeTests();
   } else {
     var testCase = testCases[_currentTestCaseIndex];
-    Future f = runZoned(testCase._run, onError: (error, stack) {
-      // TODO(kevmoo) Do a better job of flagging these are async errors.
-      // https://code.google.com/p/dart/issues/detail?id=16530
-      _registerException(testCase, error, stack);
-    });
-
+    Future f = _guardAsync(testCase._run, null, testCase);
     var timeout = unittestConfiguration.timeout;
 
     Timer timer;
     if (timeout != null) {
       try {
         timer = new Timer(timeout, () {
           testCase._error("Test timed out after ${timeout.inSeconds} seconds.");
           _nextTestCase();
         });
       } on UnsupportedError catch (e) {
@@ skipping 132 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);
 }