pkg/unittest: more lock-down, cleanup

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 128 matching lines @@
 import 'dart:collection';
 import 'dart:isolate';
 import 'package:stack_trace/stack_trace.dart';
 
 import 'matcher.dart';
 export 'matcher.dart';
 
 import 'src/utils.dart';
 
 part 'src/configuration.dart';
+part 'src/group_context.dart';
 part 'src/simple_configuration.dart';
+part 'src/spread_args_helper.dart';

[Siggi Cherem (dart-lang), 2014/02/03 18:09:46]

I was hoping we can start splitting this into multiple libraries, rather than
multiple parts. 

[kevmoo, 2014/02/03 18:22:57]

Absolutely, but in another CL. :-)

 part 'src/test_case.dart';
 
 Configuration _config;
 
 /**
  * [Configuration] used by the unittest library. Note that if a
  * configuration has not been set, calling this getter will create
  * a default configuration.
  */
 Configuration get unittestConfiguration {
@@ skipping 40 matching lines @@
 
 /**
  * The set of tests to run can be restricted by using [solo_test] and
  * [solo_group].
  * As groups can be nested we use a counter to keep track of the nest level
  * of soloing, and a flag to tell if we have seen any solo tests.
  */
 int _soloNestingLevel = 0;
 bool _soloTestSeen = false;
 
-/**
- * Setup and teardown functions for a group and its parents, the latter
- * for chaining.
- */
-class _GroupContext {
-  final _GroupContext parent;
-
-  /** Description text of the current test group. */
-  final String _name;
-
-  /** Setup function called before each test in a group. */
-  Function _testSetup;
-
-  get testSetup => _testSetup;
-
-  get parentSetup => (parent == null) ? null : parent.testSetup;
-
-  set testSetup(Function setup) {
-    var preSetup = parentSetup;
-    if (preSetup == null) {
-      _testSetup = setup;
-    } else {
-      _testSetup = () {
-        var f = preSetup();
-        if (f is Future) {
-          return f.then((_) => setup());
-        } else {
-          return setup();
-        }
-      };
-    }
-  }
-
-  /** Teardown function called after each test in a group. */
-  Function _testTeardown;
-
-  get testTeardown => _testTeardown;
-
-  get parentTeardown => (parent == null) ? null : parent.testTeardown;
-
-  set testTeardown(Function teardown) {
-    var postTeardown = parentTeardown;
-    if (postTeardown == null) {
-      _testTeardown = teardown;
-    } else {
-      _testTeardown = () {
-        var f = teardown();
-        if (f is Future) {
-          return f.then((_) => postTeardown());
-        } else {
-          return postTeardown();
-        }
-      };
-    }
-  }
-
-  String get fullName => (parent == null || parent == _rootContext)
-      ? _name
-      : "${parent.fullName}$groupSep$_name";
-
-  _GroupContext([this.parent, this._name = '']) {
-    _testSetup = parentSetup;
-    _testTeardown = parentTeardown;
-  }
-}
-
 // We use a 'dummy' context for the top level to eliminate null
 // checks when querying the context. This allows us to easily
 //  support top-level setUp/tearDown functions as well.
 final _rootContext = new _GroupContext();
 _GroupContext _currentContext = _rootContext;
 
 /**
  * Represents the index of the currently running test case
  * == -1 implies the test system is not running
  * == [number of test cases] is a short-lived state flagging that the last test
@@ skipping 75 matching lines @@
   } finally {
     --_soloNestingLevel;
   }
 }
 
 /** 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
-// arguments (if still applicable).
-class _SpreadArgsHelper {
-  final Function callback;
-  final int minExpectedCalls;
-  final int maxExpectedCalls;
-  final Function isDone;
-  final String id;
-  int actualCalls = 0;
-  final TestCase testCase;
-  bool complete;
-  static const sentinel = const _Sentinel();
-
-  _SpreadArgsHelper(Function callback, int minExpected, int maxExpected,
-      Function isDone, String id)
-      : this.callback = callback,
-        minExpectedCalls = minExpected,
-        maxExpectedCalls = (maxExpected == 0 && minExpected > 0)
-            ? minExpected
-            : maxExpected,
-        this.isDone = isDone,
-        this.testCase = currentTestCase,
-        this.id = _makeCallbackId(id, callback) {
-    ensureInitialized();
-    if (testCase == null) {
-      throw new StateError("No valid test. Did you forget to run your test "
-          "inside a call to test()?");
-    }
-
-    if (isDone != null || minExpected > 0) {
-      testCase._callbackFunctionsOutstanding++;
-      complete = false;
-    } else {
-      complete = true;
-    }
-  }
-
-  static String _makeCallbackId(String id, Function callback) {
-    // Try to create a reasonable id.
-    if (id != null) {
-      return "$id ";
-    } else {
-      // If the callback is not an anonymous closure, try to get the
-      // name.
-      var fname = callback.toString();
-      var prefix = "Function '";
-      var pos = fname.indexOf(prefix);
-      if (pos > 0) {
-        pos += prefix.length;
-        var epos = fname.indexOf("'", pos);
-        if (epos > 0) {
-          return "${fname.substring(pos, epos)} ";
-        }
-      }
-    }
-    return '';
-  }
-
-  bool 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(
-            '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;
-  }
-
-  void 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();
-    }
-  }
-
-  invoke0() {
-    return _guardAsync(
-        () {
-          if (shouldCallBack()) {
-            return callback();
-          }
-        },
-        after, testCase);
-  }
-
-  invoke1(arg1) {
-    return _guardAsync(
-        () {
-          if (shouldCallBack()) {
-            return callback(arg1);
-          }
-        },
-        after, testCase);
-  }
-
-  invoke2(arg1, arg2) {
-    return _guardAsync(
-        () {
-          if (shouldCallBack()) {
-            return callback(arg1, arg2);
-          }
-        },
-        after, testCase);
-  }
-}
-
 /**
  * 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
  * it was already complete). A value of 0 for [max] (the default) will set
  * the upper bound to the same value as [count]; i.e. the callback should be
  * called exactly [count] times. A value of -1 for [max] will mean no upper
  * bound.
  */
 // TODO(sigmund): deprecate this API when issue 2706 is fixed.

[Siggi Cherem (dart-lang), 2014/02/03 18:09:46]

BTW - now that 2706 is fixed, we can fix up a bit this API. 

I tried once using some generic 'call' method on a class, but that was not
really working. However, in another CL I just noticed a trick we can probably
use to merge expectAsync0/1/2 in a single expectAsync.

Here is the trick:

typedef _Func2(a, b);
typedef _Func1(a);
typedef _Func0();

Function expectAsync(callback, ...) {
  var helper = new _SpreadArgsHelper(...);
  if (callback is _Func2) return helper.invoke2;
  if (callback is _Func1) return helper.invoke1;
  if (callback is _Func0) return helper.invoke0;
}

We could even add more options (like definitions that accept optional arguments
and everything!)

[kevmoo, 2014/02/03 18:22:57]

I tried this awhile ago and failed because of checked mode not liking classes
with call method in some contexts. Certainly a place to investigate. ... in
another CL :-)

[Siggi Cherem (dart-lang), 2014/02/03 22:54:39]

yeah - exactly, I remember trying and failing with that too, but if we don't
generalize it to support named arguments, and just focus on merging the 3 apis
here, I think we can do it with the trick above :)

 Function expectAsync0(Function callback,
                      {int count: 1, int max: 0, String id}) {
   return new _SpreadArgsHelper(callback, count, max, null, id).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, int max: 0, String id}) {
   return new _SpreadArgsHelper(callback, count, max, null, id).invoke1;
@@ skipping 137 matching lines @@
   _runTest();
 }
 
 /** Handle errors that happen outside the tests. */
 // TODO(vsm): figure out how to expose the stack trace here
 // Currently e.message works in dartium, but not in dartc.
 void handleExternalError(e, String message, [stack]) {
   var msg = '$message\nCaught $e';
 
   if (currentTestCase != null) {
-    currentTestCase.error(msg, stack);
+    currentTestCase._error(msg, stack);
   } else {
     _uncaughtErrorMessage = "$msg: $stack";
   }
 }
 
 void rerunTests() {
   _uncaughtErrorMessage = null;
   _initialized = true; // We don't want to reset the test array.
   runTests();
 }
@@ skipping 52 matching lines @@
 void registerException(e, [trace]) {
   _registerException(currentTestCase, e, trace);
 }
 
 /**
  * Registers that an exception was caught for the current test.
  */
 void _registerException(TestCase testCase, e, [trace]) {
   String message = (e is TestFailure) ? e.message : 'Caught $e';
   if (testCase.result == null) {
-    testCase.fail(message, trace);
+    testCase._fail(message, trace);
   } else {
-    testCase.error(message, trace);
+    testCase._error(message, trace);
   }
 }
 
 /**
  * Runs the next test.
  */
 void _runTest() {
   if (_currentTestCaseIndex >= testCases.length) {
     assert(_currentTestCaseIndex == testCases.length);
     _completeTests();
   } else {
     var testCase = testCases[_currentTestCaseIndex];
     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.");
+          testCase._error("Test timed out after ${timeout.inSeconds} seconds.");
           _nextTestCase();
         });
       } on UnsupportedError catch (e) {
         if (e.message != "Timer greater than 0.") rethrow;
         // Support running on d8 and jsshell which don't support timers.
       }
     }
     f.whenComplete(() {
       if (timer != null) timer.cancel();
       var now = new DateTime.now().millisecondsSinceEpoch;
@@ skipping 61 matching lines @@
 }
 
 /** Select a solo test by ID. */
 void setSoloTest(int id) =>
   _testCases.retainWhere((t) => t.id == id);
 
 /** Enable/disable a test by ID. */
 void _setTestEnabledState(int testId, bool state) {
   // Try fast path first.
   if (testCases.length > testId && testCases[testId].id == testId) {
-    testCases[testId].enabled = state;
+    testCases[testId]._enabled = state;
   } else {
     for (var i = 0; i < testCases.length; i++) {
       if (testCases[i].id == testId) {
-        testCases[i].enabled = state;
+        testCases[i]._enabled = state;
         break;
       }
     }
   }
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
@@ skipping 39 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);
 }