pkg/unittest: locking down TestCase

pkg/unittest/lib/unittest.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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.
 
 /**
  * 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:
  *     dependencies:
@@ skipping 239 matching lines @@
  */
 Map testState = {};
 
 /**
  * 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();
-  _tests.add(new TestCase(_tests.length + 1, _fullSpec(spec), body, 0));
+  _tests.add(new TestCase._internal(_tests.length + 1, _fullSpec(spec), body));
 }
 
 /**
  * Creates a new test case with the given description and body. The
  * description will include the descriptions of any surrounding group()
  * calls.
  *
  * "solo_" means that this will be the only test that is run. All other tests
  * will be skipped. This is a convenience function to let you quickly isolate
  * a single test by adding "solo_" before it to temporarily disable all other
  * tests.
  */
 void solo_test(String spec, TestFunction body) {
   // TODO(rnystrom): Support multiple solos. If more than one test is solo-ed,
   // all of the solo-ed tests and none of the non-solo-ed ones should run.
   if (_soloTest != null) {
     throw new Exception('Only one test can be soloed right now.');
   }
 
   ensureInitialized();
 
-  _soloTest = new TestCase(_tests.length + 1, _fullSpec(spec), body, 0);
+  _soloTest = new TestCase._internal(_tests.length + 1, _fullSpec(spec), body);
   _tests.add(_soloTest);
 }
 
 /** Sentinel value for [_SpreadArgsHelper]. */
 class _Sentinel {
   const _Sentinel();
 }
 
 /** Simulates spread arguments using named arguments. */
 // TODO(sigmund): remove this class and simply use a closure with named
@@ skipping 25 matching lines @@
            _currentTest < _tests.length &&
            _tests[_currentTest] != null)) {
       print("No valid test, did you forget to run your test inside a call "
           "to test()?");
     }
     assert(_currentTest >= 0 &&
            _currentTest < _tests.length &&
            _tests[_currentTest] != null);
     testCase = _tests[_currentTest];
     if (isDone != null || minExpected > 0) {
-      testCase.callbackFunctionsOutstanding++;
+      testCase._callbackFunctionsOutstanding++;
       complete = false;
     } else {
       complete = true;
     }
   }
 
   static _makeCallbackId(String id, Function callback) {
     // Try to create a reasonable id.
     if (id != null) {
       return "$id ";
@@ skipping 14 matching lines @@
     return '';
   }
 
   shouldCallBack() {
     ++actualCalls;
     if (testCase.isComplete) {
       // Don't run if the test is done. We don't throw here as this is not
       // the current test, but we do mark the old test as having an error
       // if it previously passed.
       if (testCase.result == PASS) {
-        testCase.error(
+        testCase._error(
             'Callback ${id}called ($actualCalls) after test case '
             '${testCase.description} has already been marked as '
             '${testCase.result}.', '');
       }
       return false;
     } else if (maxExpectedCalls >= 0 && actualCalls > maxExpectedCalls) {
       throw new TestFailure('Callback ${id}called more times than expected '
                             '($maxExpectedCalls).');
     }
     return true;
   }
 
   after() {
     if (!complete) {
       if (minExpectedCalls > 0 && actualCalls < minExpectedCalls) return;
       if (isDone != null && !isDone()) return;
 
       // Mark this callback as complete and remove it from the testcase
       // oustanding callback count; if that hits zero the testcase is done.
       complete = true;
-      testCase.markCallbackComplete();
+      testCase._markCallbackComplete();
     }
   }
 
   invoke([arg0 = sentinel, arg1 = sentinel, arg2 = sentinel,
           arg3 = sentinel, arg4 = sentinel]) {
     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(
+        testCase._error(
            'unittest lib does not support callbacks with more than'
               ' 4 arguments.',
            '');
       }
     },
     after, testNum);
   }
 
   invoke0() {
     return _guardAsync(
@@ skipping 232 matching lines @@
   });
 }
 
 /**
  * Utility function that can be used to notify the test framework that an
  *  error was caught outside of this library.
  */
 void _reportTestError(String msg, String trace) {
  if (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
-    testCase.error(msg, trace);
+    testCase._error(msg, trace);
   } else {
     _uncaughtErrorMessage = "$msg: $trace";
   }
 }
 
 /**
  * Runs [callback] at the end of the event loop. Note that we don't wrap
  * the callback in guardAsync; this is for test framework functions which
  * should not be throwing unexpected exceptions that end up failing test
  * cases! Furthermore, we need the final exception to be thrown but not
@@ skipping 74 matching lines @@
   _registerException(_currentTest, e, trace);
 }
 
 /**
  * Registers that an exception was caught for the current test.
  */
 _registerException(testNum, e, [trace]) {
   trace = trace == null ? '' : trace.toString();
   String message = (e is TestFailure) ? e.message : 'Caught $e';
   if (_tests[testNum].result == null) {
-    _tests[testNum].fail(message, trace);
+    _tests[testNum]._fail(message, trace);
   } else {
-    _tests[testNum].error(message, trace);
+    _tests[testNum]._error(message, trace);
   }
 }
 
 /**
  * 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 (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 56 matching lines @@
       _soloTest = _tests[i];
       break;
     }
   }
 }
 
 /** Enable/disable a test by ID. */
 void _setTestEnabledState(int testId, bool state) {
   // Try fast path first.
   if (_tests.length > testId && _tests[testId].id == testId) {
-    _tests[testId].enabled = state;
+    _tests[testId]._enabled = state;
   } else {
     for (var i = 0; i < _tests.length; i++) {
       if (_tests[i].id == testId) {
-        _tests[i].enabled = state;
+        _tests[i]._enabled = state;
         break;
       }
     }
   }
 }
 
 /** 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();