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 42 matching lines @@
   final String currentGroup;
 
   DateTime startTime;
 
   Duration runningTime;
 
   bool enabled = true;
 
   bool _doneTeardown = false;
 
+  Completer _testComplete;
+
   TestCase(this.id, this.description, this.test,
            this.callbackFunctionsOutstanding)
   : currentGroup = _currentGroup,
     _setUp = _testSetup,
     _tearDown = _testTeardown;
 
   bool get isComplete => !enabled || result != null;
 
-  void run() {
-    if (enabled) {
-      result = stackTrace = null;
-      message = '';
-      _doneTeardown = false;
-      if (_setUp != null) {
-        _setUp();
+  void _prepTest() {
+    _config.onTestStart(this);
+    startTime = new DateTime.now();
+    runningTime = null;
+  }
+
+  Future _runTest() {
+    _prepTest();
+    test();
+    if (result == null && callbackFunctionsOutstanding == 0) {
+      pass();
+    }
+    return null;

[Siggi Cherem (dart-lang), 2013/02/11 23:14:18]

if this always returns null, shouldn't this function be 'void'?

[gram, 2013/02/11 23:50:24]

Yes, my bad, it had some other code in before that got moved to run(). Fixed.

+  }
+
+  /**
+   * Perform any associated [setUp] function and run the test. Returns
+   * a [Future] that can be used to schedule the next test. If the test runs
+   * to completion synchronously, or is disabled, we return null, to
+   * tell unittest to schedule the next test immediately.
+   */
+  Future run() {
+    if (!enabled) {
+      return null;
+    }

[Siggi Cherem (dart-lang), 2013/02/11 23:14:18]

fyi - john and I have grown to like the style where you the braces if the
condition has no else and fits in a single line, especially for 'fast-exit' code
like here. 

For instance:

if (!enabled) return null;

(see the exception in this section:
http://www.dartlang.org/articles/style-guide/#do-use-curly-braces-for-all-flo...)

[gram, 2013/02/11 23:50:24]

Done.

+
+    result = stackTrace = null;
+    message = '';
+    _doneTeardown = false;
+    if (_setUp != null) {
+      var rtn = _setUp();

[Siggi Cherem (dart-lang), 2013/02/11 23:14:18]

nit: consider merging a few of these branches, for instance:

var rtn = _setUp == null ? null : _setUp();
if (rtn is Future) {
  ...
} else {
  _setUp();
}

+      if (rtn is Future) {
+        rtn.then(expectAsync1((_) {

[Siggi Cherem (dart-lang), 2013/02/11 23:14:18]

nit: consider using =>

rtn.then(expectAsync1((_) => _runTest(),
    id: '....');

[gram, 2013/02/11 23:50:24]

Done.

+          _runTest();
+        }, id: '[Async setUp completion handler]'))
+        .catchError((e) {
+          _prepTest();
+          // 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, because 
+          // unittest will not stop at a test failure.
+          error("$description: Test setup failed: ${e.error}");
+        });
+      } else {
+        _runTest();
       }
-      _config.onTestStart(this);
-      startTime = new DateTime.now();
-      runningTime = null;
-      test();
+    } else {
+      _runTest();
+    }
+    if (result == null) { // Not complete.
+      _testComplete = new Completer();
+      return _testComplete.future;
+    }
+    return null;
+  }
+
+  void _nextTest() {

[Siggi Cherem (dart-lang), 2013/02/11 23:14:18]

nit: rename, '_markComplete'?

[gram, 2013/02/11 23:50:24]

I went for _notifyComplete

+    if (_testComplete != null) {
+      _testComplete.complete(this);
+      _testComplete = null;
     }
   }
 
   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);
     }
     if (!_doneTeardown) {
+      _doneTeardown = 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);
+            }
+            _nextTest();
+          }, id: '[Async tearDown completion handler]'))
+          .catchError((e) {
+            // 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);
+            _nextTest();
+          });
+          return;
+        }
       }
-      _doneTeardown = true;
     }
     _config.onTestResult(this);
+    _nextTest();
   }
 
   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();
   }
 }