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 309 matching lines @@
  */
 // TODO(sigmund): deprecate this API when issue 2706 is fixed.
 Function expectAsyncUntil2(Function callback, Function isDone) {
   return new _SpreadArgsHelper.variableCallCount(callback, isDone).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()) {
+void group(String description, void body(),
+           [Function setupTest, Function teardownTest]) {

[Bob Nystrom, 2012/06/20 20:21:22]

Since you added setUp() and tearDown(), do you still think it's useful to have
these here too?

[gram, 2012/06/20 21:11:47]

Done.

   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.

[Bob Nystrom, 2012/06/20 20:21:22]

It might be useful at some point to actually allow nested setups and call all of
them (probably outermost first for setup and innermost first for teardown).

[gram, 2012/06/20 21:11:47]

I think this could be tricky. There may be cases where people want the the outer
ones run only once for the group, not once per inner test. The inner ones can
always call the outer ones so I think this restriction is okay.

+ * [setUp] and [tearDown] should be called within the [group] before any
+ * calls to [test].
+ */
+
+void setUp(Function setupTest) {

[Bob Nystrom, 2012/06/20 20:21:22]

Remove blank line above this.

[gram, 2012/06/20 21:11:47]

Done.

+  _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) {

[Bob Nystrom, 2012/06/20 20:21:22]

Remove blank line above this.

[gram, 2012/06/20 21:11:47]

Done.

+  _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++;
@@ skipping 103 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();