Add new features to package:async.

test/stream_completer_test.dart

Index: test/stream_completer_test.dart
diff --git a/test/stream_completer_test.dart b/test/stream_completer_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..8996485fb11502c8c81566833d7a2419d68f106e
--- /dev/null
+++ b/test/stream_completer_test.dart
@@ -0,0 +1,94 @@
+// 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 async.stream_completer_test;

[nweiz, 2015/06/12 01:24:27]

Tests don't need library annotations.

+
+import "dart:async";
+
+import "package:async/async.dart" show StreamCompleter;
+import "package:test/test.dart";
+
+main() {
+  test("early link", () async {

[nweiz, 2015/06/12 01:24:27]

Rather than "early" and "late" consider spelling out exactly at what point in
the lifecycle a link is being made. The test API is designed explicitly to make
it possible to use full sentences or sentence fragments; for example, "a source
stream is set before the completer is listened to."

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Done.

+    var c = new StreamCompleter();

[nweiz, 2015/06/12 01:24:27]

Use full words for variables.

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Done.

+    var s = c.stream;

[nweiz, 2015/06/12 01:24:27]

Pulling this out into a variable makes this harder to follow, especially when
the variable is declared so far away from where it's used.

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Done.

+    c.setSourceStream(createStream());
+    var r = [];
+    await s.listen(r.add).asFuture();

[nweiz, 2015/06/12 01:24:27]

Consider just:

    expect(s.toList(), completion(equals([1, 2, 3, 4])));

Since you're not writing tests for the Stream base class, it's fine to assume
that [Stream.toList] will translate reasonably into a call to [listen].

Same goes elsewhere in this file.

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Done.

+    expect(r, [1, 2, 3, 4]);
+  });
+
+  test("later link", () async {
+    var c = new StreamCompleter();
+    var s = c.stream;
+    var r = [];
+    Future done = s.listen(r.add).asFuture();
+    await sleep(250);

[nweiz, 2015/06/12 01:24:27]

Sleeping is a recipe for tests that are both slow and flaky. If you need to
ensure that all microtask-level events have finished firing, just use "await new
Future.delayed(Duration.ZERO)". If there are non-microtask-level events in this
code, that's a problem anyway.

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Switched to flushing microtasks (aka timer 0 future).

+    c.setSourceStream(createStream());
+    await done;
+    expect(r, [1, 2, 3, 4]);
+  });
+
+  test("early cancel", () async {
+    var c = new StreamCompleter();
+    var s = c.stream;
+    var sub = s.listen(null);
+    sub.pause();  // Should be ignored.
+    sub.cancel();
+    c.setSourceStream(new UnusableStream());  // Doesn't throw.
+  });
+
+  test("early pause", () async {
+    var c = new StreamCompleter();
+    var s = c.stream;
+    var r = [];
+    var sub = s.listen(r.add);
+    Future done = sub.asFuture();
+    sub.pause();
+    c.setSourceStream(createStream());
+    await sleep(250);
+    expect(r, []);
+    sub.resume();
+    await done;
+    expect(r, [1, 2, 3, 4]);
+  });
+
+  test("multi-pause", () async {
+    var c = new StreamCompleter();
+    var s = c.stream;
+    var r = [];
+    var sub = s.listen(r.add);
+    Future done = sub.asFuture();
+    sub.pause();
+    sub.pause();
+    sub.pause();
+    c.setSourceStream(createStream());
+    for (int i = 0; i < 3; i++) {
+      await sleep(50);
+      expect(r, []);
+      sub.resume();
+    }
+    await done;
+    expect(r, [1, 2, 3, 4]);
+  });
+}

[nweiz, 2015/06/12 01:24:27]

There's a bunch of publicly-visible behavior that isn't tested for:

* Pausing/canceling the stream after the completer has fired but before the
stream is complete.

* [setEmpty].

* Ensuring that [listen] isn't called on the underlying stream until the stream
completer is listened to.

* Ensuring that [cancelOnError] is forwarded properly, both when the completer
stream is listened to before and after it's linked.

* Handling errors, both before and after linking.

* Linking a stream more than once.

* Listening to a completer stream more than once.

* Setting onData/onError/onDone on the completer subscription, both before and
after it's linked.

[Lasse Reichstein Nielsen, 2015/06/15 15:46:24]

Good points. Many more tests added.

+
+const MS = const Duration(milliseconds: 1);
+Future sleep(int n) => new Future.delayed(MS * n);
+
+Stream<int> createStream() async* {
+  yield 1;
+  await sleep(20);
+  yield 2;
+  await sleep(10);
+  yield 3;
+  await sleep(15);
+  yield 4;
+}
+
+class UnusableStream extends Stream {
+  listen(onData, {onError, onDone, cancelOnError}) {
+    throw new UnimplementedError("Gotcha!");
+  }
+}