setUp/tearDown functions can now be asynchronous.

pkg/unittest/lib/src/test_case.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.
 
 part of unittest;
 
 /**
  * testcase.dart: this file is sourced by unittest.dart. It defines [TestCase]
  * and assumes unittest defines the type [TestFunction].
  */
@@ skipping 50 matching lines @@
   bool _doneTeardown = false;
 
   TestCase(this.id, this.description, this.test,
            this.callbackFunctionsOutstanding)
   : currentGroup = _currentGroup,
     _setUp = _testSetup,
     _tearDown = _testTeardown;
 
   bool get isComplete => !enabled || result != null;
 
+  void _prepTest() {
+    _config.onTestStart(this);
+    startTime = new DateTime.now();
+    runningTime = null;
+  }
+
   void run() {
     if (enabled) {
       result = stackTrace = null;
       message = '';
       _doneTeardown = false;
       if (_setUp != null) {
-        _setUp();
+        var rtn = _setUp();
+        if (rtn is Future) {
+          rtn.then(expectAsync1((_) {
+                _prepTest();
+                test();
+              }, id: '[Async setUp completion handler]'))
+             .catchError((e) {

[justinfagnani, 2013/02/08 01:36:48]

Make sure you always call catchError() before then()

[gram, 2013/02/08 17:52:24]

Why?

[Siggi Cherem (dart-lang), 2013/02/08 18:02:22]

to clarify: as long as the futures are chained, the order doesn't matter anymore
(that used to be important with handleException, but not anymore). the only
distinction is, what is it that you are trapping. catchError should go before
'then' if you don't want to catch any errors in the body of 'then'. In this
case, I think Justin concern is valid: test() will throw 'expect' errors, and
those will be caught by 'catchError' here. Is that what we want?

[justinfagnani, 2013/02/08 18:36:57]

Good catch. I was mentally using the old pattern, but your point is important.

+               _prepTest();

[justinfagnani, 2013/02/08 01:36:48]

why call _prepTest() when there's an error?

[gram, 2013/02/08 17:52:24]

We are going to treat this like a regular test error, so I think it is still a
good idea to call config.ontestStart (in the error handling we will call
onTestResult with the error result; calling that without having called
ontestStart may have unintended consequences depending on the configuration).

+               // Calling error() will result in the tearDown being done.
+               // One could debate whether tearDown should be done after
+               // a failed setUp. There is no right answer, but doing it
+               // seems to be the more conservative approach.
+               error("$description: Test setup failed: ${e.error}");
+             });
+          return;
+        }
       }
-      _config.onTestStart(this);
-      startTime = new DateTime.now();
-      runningTime = null;
+      _prepTest();

[justinfagnani, 2013/02/08 01:36:48]

Looks like for async setup _prepTest() and test() are called twice.

[gram, 2013/02/08 17:52:24]

No, there is a return statement in the block.

[justinfagnani, 2013/02/08 18:36:57]

Oops

       test();
+    } else {
+      _nextTestCase();
     }
   }
 
   void _complete() {
     if (runningTime == null) {
       // TODO(gram): currently the duration measurement code is blocked
       // by issue 4437. When that is fixed replace the line below with:
       //    runningTime = new DateTime.now().difference(startTime);
       runningTime = new Duration(milliseconds: 0);
     }
+    bool mustRunNextTest = false;
     if (!_doneTeardown) {
+      _doneTeardown = true;
+      mustRunNextTest = true;
       if (_tearDown != null) {
-        _tearDown();
+        var rtn = _tearDown();
+        if (rtn is Future) {
+          rtn.then(expectAsync1((_) {
+              if (result == null) {
+                // The test passed. In some cases we will already
+                // have set this result (e.g. if the test was async
+                // and all callbacks completed). If not, we do it here.
+                pass();
+              } else {
+                // The test has already been marked as pass/fail.
+                // Just report the updated result.
+                _config.onTestResult(this);
+              }
+              _nextTestCase();
+             }, id: '[Async tearDown completion handler]'))
+            .catchError((e) {

[justinfagnani, 2013/02/08 01:36:48]

Make sure you always call catchError() before then()

+              // We don't call fail() as that will potentially result in
+              // spurious messages like 'test failed more than once'.
+              result = ERROR;
+              message = "$description: Test teardown failed: ${e.error}";
+              _config.onTestResult(this);
+              _nextTestCase();
+             });
+          return;
+        }
       }
-      _doneTeardown = true;
     }
     _config.onTestResult(this);
+    if (mustRunNextTest) {
+      _nextTestCase();
+    }
   }
 
   void pass() {
     result = PASS;
     _complete();
   }
 
   void fail(String messageText, [String stack = '']) {
     if (result != null) {
       if (result == PASS) {
         error('Test failed after initially passing: $messageText', stack);
       } else if (result == FAIL) {
         error('Test failed more than once: $messageText', stack);
       }
     } else {
       result = FAIL;
       message = messageText;
       stackTrace = stack;
       _complete();
     }
   }
 
   void error(String messageText, [String stack = '']) {
     result = ERROR;
     message = messageText;
     stackTrace = stack;
     _complete();
   }
 }