pkg/unittest: simplify guardAsync

pkg/unittest/lib/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.
  *
  * To import this library, use the pub package manager.
  * Create a pubspec.yaml file in your project and add
  * a dependency on unittest with the following lines:
@@ skipping 372 matching lines @@
       complete = true;
       if (--testCase.callbackFunctionsOutstanding == 0 &&
          !testCase.isComplete) {
         testCase.pass();
       }
     }
   }
 
   invoke([arg0 = sentinel, arg1 = sentinel, arg2 = sentinel,
           arg3 = sentinel, arg4 = sentinel]) {
-    return guardAsync(() {
+    return _guardAsync(() {
       if (!shouldCallBack()) {
         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.',
            '');
       }
     },
     after, testNum);
   }
 
   invoke0() {
-    return guardAsync(
+    return _guardAsync(
         () {
           if (shouldCallBack()) {
             return callback();
           }
         },
         after, testNum);
   }
 
   invoke1(arg1) {
-    return guardAsync(
+    return _guardAsync(
         () {
           if (shouldCallBack()) {
             return callback(arg1);
           }
         },
         after, testNum);
   }
 
   invoke2(arg1, arg2) {
-    return guardAsync(
+    return _guardAsync(
         () {
           if (shouldCallBack()) {
             return callback(arg1, arg2);
           }
         },
         after, testNum);
   }
 }
 
 /**
@@ skipping 268 matching lines @@
     _testRunner();
   });
 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, it is
  * passed to the corresponding test.
  *
  * The value returned by [tryBody] (if any) is returned by [guardAsync].
  */
-guardAsync(Function tryBody, [Function finallyBody, int testNum = -1]) {
-  if (testNum < 0) testNum = _currentTest;
+guardAsync(Function tryBody) {
+  return _guardAsync(tryBody, null, _currentTest);
+}
+
+_guardAsync(Function tryBody, Function finallyBody, int testNum) {
+  assert(testNum >= 0);
   try {
     return tryBody();
   } catch (e, trace) {
     _registerException(testNum, e, trace);
   } finally {
     if (finallyBody != null) finallyBody();
   }
 }
 
 /**
@@ skipping 21 matching lines @@
  * running. Tests will resume executing when such asynchronous test calls
  * [done] or if it fails with an exception.
  */
 _nextBatch() {
   while (true) {
     if (_currentTest >= _tests.length) {
       _completeTests();
       break;
     }
     final testCase = _tests[_currentTest];
-    var f = guardAsync(testCase.run, null, _currentTest);
+    var f = _guardAsync(testCase.run, null, _currentTest);
     if (f != null) {
       f.whenComplete(() {
         _nextTestCase(); // Schedule the next test.
       });
       break;
     }
     _currentTest++;
   }
 }
 
@@ skipping 75 matching lines @@
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef dynamic TestFunction();