Call asyncEnd only on success.

pkg/async_helper/lib/async_helper.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.
 
 /// This library is used for testing asynchronous tests.
 /// If a test is asynchronous, it needs to notify the testing driver
 /// about this (otherwise tests may get reported as passing [after main()
 /// finished] even if the asynchronous operations fail).
 /// Tests which can't use the unittest framework should use the helper functions
 /// in this library.
@@ skipping 14 matching lines @@
 import 'dart:isolate';
 
 bool _initialized = false;
 ReceivePort _port = null;
 int _asyncLevel = 0;
 
 Exception _buildException(String msg) {
   return new Exception('Fatal: $msg. This is most likely a bug in your test.');
 }
 
+/// Call this method before an asynchronous test is created.
 void asyncStart() {
   if (_initialized && _asyncLevel == 0) {
     throw _buildException('asyncStart() was called even though we are done '
                           'with testing.');
   }
   if (!_initialized) {
     print('unittest-suite-wait-for-done');
     _initialized = true;
     _port = new ReceivePort();
   }
   _asyncLevel++;
 }
 
+/// Call this after an asynchronous test has ended successfully.
 void asyncEnd() {
   if (_asyncLevel <= 0) {
     if (!_initialized) {
       throw _buildException('asyncEnd() was called before asyncStart().');
     } else {
       throw _buildException('asyncEnd() was called more often than '
                             'asyncStart().');
     }
   }
   _asyncLevel--;
   if (_asyncLevel == 0) {
     _port.close();
     _port = null;
     print('unittest-suite-success');
   }
 }

[kustermann, 2013/09/09 12:41:54]

In general I've noticed that people misuse these two methods sometimes. This
test for example is broken
main() {
  asyncStart();
  Timer.run(() { print("A"); asyncEnd(); });
  asyncStart();
  Timer.run(() { print("B"); asyncEnd(); });
}

It could be the case that the first closure was called twice (i.e. the result is
"AA") and the test would pass.

Maybe we should provide a convenience wrapper around asyncStart/asyncEnd, like
this:
main() {
  var asyncEndFn1 = asyncBegin();
  Timer.run(() { print("A"); asyncEndFn1(); });
  var asyncEndFn2 = asyncBegin();
  Timer.run(() { print("B"); asyncEndFn2(); });
}

So returning a closure which makes sure that it's only called once.

 
+/**
+ * Call this after an asynchronous test has ended successfully. This is a helper
+ * for calling [asyncEnd].
+ *
+ * This method intentionally has a signature that matches [:Future.then:] as a
+ * convenience for calling [asyncEnd] when a [:Future:] completes without error,
+ * like this:
+ *
+ *     asyncStart();
+ *     Future result = test();
+ *     result.then(asyncSuccess);
+ */
+void asyncSuccess(_) => asyncEnd();
+
+/**
+ * Helper method for performing asynchronous tests involving [:Future:].
+ *
+ * [f] must return a [:Future:] for the test computation.
+ */
 void asyncTest(f()) {

[kustermann, 2013/09/09 12:41:54]

Either document this on the top of the file or at the method level. be
consistent (i.e. remove the comments on the top or add sections for these
methods as well).

[Johnni Winther, 2013/09/13 07:34:59]

Added a top comment as well.

   asyncStart();
-  f().whenComplete(() => asyncEnd());
+  f().then(asyncSuccess);
 }