blob: 4401a468d4e8e444dc54aa70b3973678026cdee8 [file] [log] [blame]
// Copyright (c) 2016, 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.
import "dart:async";
import "package:async_helper/async_helper.dart";
/// This test verifies that an await for loop sends the correct
/// signals to the stream it iterates over:
/// 1) A listen event.
/// 2) A pause event when the loop body is awaiting something,
/// and more elements arrive on the stream. See issue
/// .
/// 3) A resume event, when the loop is again ready to iterate.
main() {
Completer listenEventReceived = new Completer();
Completer pauseEventReceived = new Completer();
Completer resumeEventReceived = new Completer();
StreamController controller = new StreamController(
onListen: () => listenEventReceived.complete(),
onPause: () => pauseEventReceived.complete(),
onResume: () => resumeEventReceived.complete());
Completer forLoopEntered = new Completer();
/// The send function puts items on the stream. It waits for a
/// listener, puts "first" on the stream, waits for the for loop
/// to start (and eventually block), puts "second" on the stream
/// multiple times, letting the event loop run, until the for loop
/// pauses the stream because it it blocked.
/// The for loop unblocks after the pause message is received, and
/// reads the stream items, sending a stream resume message when it
/// is ready for more.
/// Then the send function puts a final "third" on the stream, and
/// closes the stream.
send() async {
await listenEventReceived.future;
await forLoopEntered.future;
var timer = new Timer.periodic(new Duration(milliseconds: 10), (timer) {
await pauseEventReceived.future;
// pauseEventReceived.future completes when is
// paused by the await-for loop below. What's specified is that
// await-for must pause immediately on an "await", but instead
// the implementations agree on not pausing until receiving the
// next event. For this reason, [timer] will call its callback at
// least once before we cancel it again.
await resumeEventReceived.future;
receive() async {
bool thirdReceived = false;
await for (var entry in {
if (entry == 'first') {
await pauseEventReceived.future;
} else if (entry == 'third') {
thirdReceived = true;
if (!thirdReceived) {
throw "Error in await-for loop: 'third' not received";
asyncTest(() async {
// We need to start both functions in parallel, and wait on them both.
var f = send();
await receive();
await f;