#1363. Yield each tests updated to the current specification (#1374)

Authored by @sgrekhov.

Yield-each tests updated and new ones added; some delays replaced by `await null;`; do not to rely on delays, but use a completer (to avoid having flakiness during high loads, and in general to avoid depending on scheduling order and timing).

Author: sgrekhov

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A01_t01.dart

@@ -0,0 +1,43 @@
+// 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that dynamic error occurs if the class of `o` does not
+/// implement `Stream<T>`.
+///
+/// @issue #25634 - the test assumes that dynamic error is added to the stream.
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator() async* {
+  dynamic a = 'a';
+  yield* a;
+}
+
+main() {
+  asyncStart();
+  generator().listen((_) {}, onError: (e) {
+    Expect.isTrue(e is Error);
+    asyncEnd();
+  });
+}

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A02_t01.dart

@@ -0,0 +1,67 @@
+// Copyright (c) 2022, 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that if there is an enclosing asynchronous for loop, it
+/// is paused
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<Object> generator(Stream<int> input1, Stream<String> input2) async* {
+  await for (var v in input1) {
+    yield v;
+    if (v == 2) {
+      yield* input2;
+    }
+  }
+}
+
+Future test() async {
+  List log = [];
+  Stream<String> input2 = Stream<String>.fromIterable(['a', 'b', 'c']);
+  StreamController<int> sc = new StreamController<int>();
+  Stream<Object> s = generator(sc.stream, input2);
+  StreamSubscription<Object> ss = s.listen((Object o) {
+    log.add(o);
+    if (o is String) {
+      Expect.isTrue(sc.isPaused);
+    }
+  }, onDone: () {
+    Expect.listEquals([1, 2, 'a', 'b', 'c', 3], log);
+    asyncEnd();
+  });
+  sc.add(1);
+  await null;
+  sc.add(2);
+  await null;
+  sc.add(3);
+  await null;
+  ss.resume();
+  await sc.close();
+}
+
+main() {
+  asyncStart();
+  test();
+}

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A03_t01.dart

@@ -0,0 +1,64 @@
+// 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that if the stream `u` associated with `m` has been
+/// paused, then execution of `m` is suspended until `u` is resumed. Using
+/// `StreamController` as input data supplier.
+///
+/// @author [email protected]
+/// @issue 42584
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator(Stream<int> input) async* {
+  yield* input;
+}
+
+Future test() async {
+  List log = [];
+  StreamController<int> sc = new StreamController<int>();
+  Stream<int> s = generator(sc.stream);
+  StreamSubscription<int> ss = s.listen((int i) {
+    log.add(i);
+  }, onDone: () {
+    Expect.listEquals(['a', 'b', 'c', 1, 2, 3], log);
+    asyncEnd();
+  });
+  ss.pause();
+  sc.add(1);
+  await null;
+  log.add('a');
+  sc.add(2);
+  await null;
+  log.add('b');
+  sc.add(3);
+  await null;
+  log.add('c');
+  ss.resume();
+  await sc.close();
+}
+
+main() {
+  asyncStart();
+  test();
+}

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A03_t02.dart

@@ -0,0 +1,60 @@
+// 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that if the stream `u` associated with `m` has been
+/// paused, then execution of `m` is suspended until `u` is resumed. Using
+/// `Completer` to control generator execution before `yield*` statement.
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator(Stream<int> input, Future startTrigger) async* {
+  await startTrigger;
+  yield* input;
+}
+
+Future test() async {
+  List log = [];
+  Completer c = new Completer();
+  Stream<int> s = generator(new Stream.fromIterable([1, 2, 3]), c.future);
+  StreamSubscription<int> ss = s.listen((int i) {
+    log.add(i);
+  }, onDone: () {
+    Expect.listEquals(['a', 'b', 'c', 1, 2, 3], log);
+    asyncEnd();
+  });
+  ss.pause();
+  c.complete(); // Return control to yield*
+  log.add('a');
+  await null;
+  log.add('b');
+  await null;
+  log.add('c');
+  ss.resume();
+}
+
+main() {
+  asyncStart();
+  test();
+}

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A03_t03.dart

@@ -0,0 +1,61 @@
+// 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that if the stream `u` associated with `m` has been
+/// paused, then execution of `m` is suspended until `u` is cancelled. Using
+/// `StreamController` as input data supplier.
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator(Stream<int> input) async* {
+  yield* input;
+}
+
+Future test() async {
+  List log = [];
+  StreamController<int> sc = new StreamController<int>();
+  Stream<int> s = generator(sc.stream);
+  StreamSubscription<int> ss = s.listen((int i) {
+    log.add(i);
+  });
+  ss.pause();
+  sc.add(1);
+  await null;
+  log.add('a');
+  sc.add(2);
+  await null;
+  log.add('b');
+  sc.add(3);
+  await null;
+  log.add('c');
+  await ss.cancel();
+  await sc.close();
+  Expect.listEquals(['a', 'b', 'c'], log);
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}

Language/Statements/Yield_and_Yield_Each/Yield_Each/execution_async_A03_t04.dart

@@ -0,0 +1,58 @@
+// 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.
+
+/// @assertion If `m` is marked `async*`, then:
+///   • It is a dynamic error if the class of o does not implement `Stream<T>`.
+///  Otherwise
+///   • The nearest enclosing asynchronous for loop, if any, is paused.
+///   • The `o` stream is listened to, creating a subscription `s`, and for each
+///    event `x`, or error `e` with stack trace `t`, of `s`:
+///      – If the stream `u` associated with `m` has been paused, then execution
+///         of `m` is suspended until `u` is resumed or canceled.
+///      – If the stream `u` associated with `m` has been canceled, then `s` is
+///      canceled by evaluating `await v.cancel()` where `v` is a fresh variable
+///      referencing the stream subscription `s`. Then, if the cancel completed
+///      normally, the stream execution of `s` returns without an object.
+///      – Otherwise, `x`, or `e` with `t`, are added to the stream associated
+///      with `m` in the order they appear in `o`. Note that a dynamic error
+///      occurs if `x` is added and the dynamic type of `x` is not a subtype of
+///      the element type of said stream. The function `m` may suspend.
+///   • If the stream `o` is done, execution of `s` completes normally.
+///
+/// @description Check that if the stream `u` associated with `m` has been
+/// paused, then execution of `m` is suspended until `u` is cancelled. Using
+/// `Completer` to control generator execution before `yield*` statement.
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator(Stream<int> input, Future startTrigger) async* {
+  await startTrigger;
+  yield* input;
+}
+
+Future test() async {
+  List log = [];
+  Completer c = new Completer();
+  Stream<int> s = generator(new Stream.fromIterable([1, 2, 3]), c.future);
+  StreamSubscription<int> ss = s.listen((int i) {
+    log.add(i);
+  });
+  ss.pause();
+  c.complete(); // pass control to yield*
+  log.add('a');
+  await null;
+  log.add('b');
+  await null;
+  log.add('c');
+  await ss.cancel();
+  Expect.listEquals(['a', 'b', 'c'], log);
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}