Accept a computation that returns a Future for Future.delayed.

tests/lib/async/future_constructor2_test.dart

Index: tests/lib/async/future_constructor2_test.dart
diff --git a/tests/lib/async/future_constructor2_test.dart b/tests/lib/async/future_constructor2_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..8f0b3a49fe2f9f4f488da3509f03ad1aa5bb5b55
--- /dev/null
+++ b/tests/lib/async/future_constructor2_test.dart
@@ -0,0 +1,60 @@
+// Copyright (c) 2015, 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.
+
+library future_delayed_test;
+
+import 'package:async_helper/async_helper.dart';
+import "package:expect/expect.dart";
+import 'dart:async';
+
+Future<int> voidToIntFuture() {

[Lasse Reichstein Nielsen, 2015/08/14 22:05:04]

drop the "void" - just "intFunction". void is only meaningful as a return value.
The absence of a parameter is not the same as a void parameter.

[floitsch, 2015/08/17 09:34:30]

renamed to 'createIntFuture'.

+  return new Future<int>.value(499);
+}
+
+unnamed() {
+  asyncStart();
+  new Future<int>(voidToIntFuture)
+      .then((x) {
+    Expect.equals(499, x);
+    asyncEnd();
+  });
+}
+
+delayed() {
+  asyncStart();
+  new Future<int>.delayed(const Duration(milliseconds: 2), voidToIntFuture)
+      .then((x) {
+    Expect.equals(499, x);
+    asyncEnd();
+  });
+}
+
+microtask() {
+  asyncStart();
+  new Future<int>.microtask(voidToIntFuture)
+      .then((x) {
+    Expect.equals(499, x);
+    asyncEnd();
+  });
+}
+
+sync() {
+  asyncStart();
+  new Future<int>.sync(voidToIntFuture)
+      .then((x) {
+    Expect.equals(499, x);
+    asyncEnd();
+  });
+}
+
+main() {

[Lasse Reichstein Nielsen, 2015/08/14 22:05:04]

I'd prefer if main stared with asyncStart() and ended with asyncEnd().

It prevents the annoying case where the first function called manages to call
its asyncEnd before returning.

It won't happen with the current tests, but it's easy to accidentally write one.

[floitsch, 2015/08/17 09:34:30]

Done.

+  // Test that all the Future constructors take functions that return a Future
+  // as argument.
+  // In particular the constructors must not type their argument as
+  // `T computation()`.
+  unnamed();
+  delayed();
+  microtask();
+  sync();
+}