Added test setup/teardown.

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.
  *
  * To import this library, specify the relative path to
  * lib/unittest/unittest.dart.
  *
@@ skipping 137 matching lines @@
 #source('map_matchers.dart');
 #source('matcher.dart');
 #source('numeric_matchers.dart');
 #source('operator_matchers.dart');
 #source('string_matchers.dart');
 #source('test_case.dart');
 
 /** [Configuration] used by the unittest library. */
 Configuration _config = null;
 
-/** Set the [Configuration] used by the unittest library. */
-void configure(Configuration config) {
+/**
+ * Set the [Configuration] used by the unittest library. Returns any
+ * previous configuration.
+ */
+Configuration configure(Configuration config) {
+  Configuration _oldConfig = _config;
   _config = config;
+  return _oldConfig;
 }
 
 /**
  * Description text of the current test group. If multiple groups are nested,
  * this will contain all of their text concatenated.
  */
 String _currentGroup = '';
 
 /** Tests executed in this suite. */
 List<TestCase> _tests;
 
 /**
  * Callback used to run tests. Entrypoints can replace this with their own
  * if they want.
  */
 Function _testRunner;
 
+/** Setup function called before each test in a group */
+Function _testSetup;
+
+/** Teardown function called after each test in a group */
+Function _testTeardown;
+
 /** Current test being executed. */
 int _currentTest = 0;
 
 /** Total number of callbacks that have been executed in the current test. */
 int _callbacksCalled = 0;
 
 final _UNINITIALIZED = 0;
 final _READY         = 1;
 final _RUNNING_TEST  = 2;
 
@@ skipping 110 matching lines @@
 class _SpreadArgsHelper {
   Function _callback;
   int _expectedCalls;
   int _calls = 0;
   TestCase _testCase;
   Function _shouldCallBack;
   Function _isDone;
 
   _init(Function callback, Function shouldCallBack, Function isDone,
        [expectedCalls = 0]) {
+    ensureInitialized();
     assert(_currentTest < _tests.length);
     _callback = callback;
     _shouldCallBack = shouldCallBack;
     _isDone = isDone;
     _expectedCalls = expectedCalls;
     _testCase = _tests[_currentTest];
     if (expectedCalls > 0) {
       _testCase.callbacks++;
     }
   }
 
   _SpreadArgsHelper(callback, shouldCallBack, isDone) {
     _init(callback, shouldCallBack, isDone);
   }
 
   _SpreadArgsHelper.fixedCallCount(callback, expectedCalls) {
     _init(callback, _checkCallCount, _allCallsDone, expectedCalls);
   }
 
   _SpreadArgsHelper.variableCallCount(callback, isDone) {
-    _init(callback, _always, isDone);
-  }
+    _init(callback, _always, isDone, 1);
+   }
 
   _after() {
     if (_isDone()) {
       _handleAllCallbacksDone();
     }
   }
 
   _allCallsDone() => _calls == _expectedCalls;
 
   _always() {
@@ skipping 161 matching lines @@
 }
 
 /**
  * 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();
 
   // Concatenate the new group.
-  final oldGroup = _currentGroup;
+  final parentGroup = _currentGroup;
   if (_currentGroup != '') {
     // Add a space.
     _currentGroup = '$_currentGroup $description';
   } else {
     // The first group.
     _currentGroup = description;
   }
 
+  // Groups can be nested, so we need to preserve the current
+  // settings for test setup/teardown.
+  Function parentSetup = _testSetup;
+  Function parentTeardown = _testTeardown;
+
   try {
+    _testSetup = null;
+    _testTeardown = null;
     body();
   } finally {
     // Now that the group is over, restore the previous one.
-    _currentGroup = oldGroup;
+    _currentGroup = parentGroup;
+    _testSetup = parentSetup;
+    _testTeardown = parentTeardown;
   }
 }
 
+/**
+ * Register a [setUp] function for a test [group]. This function will
+ * be called before each test in the group is run. Note that if groups
+ * are nested only the most locally scoped [setUp] function will be run.
+ * [setUp] and [tearDown] should be called within the [group] before any
+ * calls to [test].
+ */
+void setUp(Function setupTest) {
+  _testSetup = setupTest;
+}
+
+/**
+ * Register a [tearDown] function for a test [group]. This function will
+ * be called after each test in the group is run. Note that if groups
+ * are nested only the most locally scoped [tearDown] function will be run.
+ * [setUp] and [tearDown] should be called within the [group] before any
+ * calls to [test].
+ */
+void tearDown(Function teardownTest) {
+  _testTeardown = teardownTest;
+}
+
 /** Called by subclasses to indicate that an asynchronous test completed. */
 void _handleAllCallbacksDone() {
   // TODO (gram): we defer this to give the nextBatch recursive
   // stack a chance to unwind. This is a temporary hack but
   // really a bunch of code here needs to be fixed. We have a
   // single array that is being iterated through by nextBatch(),
   // which is recursively invoked in the case of async tests that
   // run synchronously. Bad things can then happen.
   _defer(() {
     _callbacksCalled++;
     if (_currentTest < _tests.length) {
       final testCase = _tests[_currentTest];
       if (_callbacksCalled > testCase.callbacks) {
         final expected = testCase.callbacks;
         testCase.error(
-            'More calls to callbackDone() than expected. '
+            'More calls to _handleAllCallbacksDone() than expected. '
             'Actual: ${_callbacksCalled}, expected: ${expected}', '');
         _state = _UNCAUGHT_ERROR;
       } else if ((_callbacksCalled == testCase.callbacks) &&
           (_state != _RUNNING_TEST)) {
         if (testCase.result == null) {
           testCase.pass();
         }
         _currentTest++;
         _testRunner();
       }
@@ skipping 87 matching lines @@
  * 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 (_currentTest < _tests.length) {
     final testCase = _tests[_currentTest];
     guardAsync(() {
       _callbacksCalled = 0;
       _state = _RUNNING_TEST;
-      testCase.test();
+      testCase.run();
 
       if (_state != _UNCAUGHT_ERROR) {
         if (testCase.callbacks == _callbacksCalled) {
           testCase.pass();
         }
       }
     });
 
     if (!testCase.isComplete && testCase.callbacks > 0) return;
 
@@ skipping 51 matching lines @@
   _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();