dart-lang#1363. Tests for yield updated to the current specification

Author: sgrekhov

Language/Statements/Yield_and_Yield_Each/Yield/async_delivery_t01.dart

@@ -30,39 +30,32 @@ import '../../../../Utils/expect.dart';
 List<int> readyToSent = [];
 List<int> sent = [];
 
-Stream<int> generator(List log) async* {
+Stream<int> generator() async* {
   for (int i = 1; i <= 3; i++) {
     readyToSent.add(i);
     yield i;
     sent.add(i);
   }
 }
 
-test() async {
-  List received = [];
-  Stream<int> s = generator(received);
-  late StreamSubscription<int> ss;
-  ss = s.listen(
-      (int i) async {
-        received.add(i);
-        if (i == 1) {
-          ss.pause();
-          await Future.delayed(Duration(milliseconds: 100));
-          Expect.listEquals([], sent);
-          Expect.listEquals([1], readyToSent);
-          ss.resume();
-        }
-      },
-      onDone:() {
-        Expect.listEquals([1, 2, 3], received);
-        Expect.listEquals(sent, received);
-        Expect.listEquals(readyToSent, received);
-        asyncEnd();
-      }
-  );
-}
-
 main() {
   asyncStart();
-  test();
+  List received = [];
+  Stream<int> s = generator();
+  late StreamSubscription<int> ss;
+  ss = s.listen((int i) async {
+    received.add(i);
+    if (i == 1) {
+      ss.pause();
+      await Future.delayed(Duration(milliseconds: 100));
+      Expect.listEquals([], sent);
+      Expect.listEquals([1], readyToSent);
+      ss.resume();
+    }
+  }, onDone: () {
+    Expect.listEquals([1, 2, 3], received);
+    Expect.listEquals(sent, received);
+    Expect.listEquals(readyToSent, received);
+    asyncEnd();
+  });
 }

Language/Statements/Yield_and_Yield_Each/Yield/execution_async_t01.dart renamed to Language/Statements/Yield_and_Yield_Each/Yield/execution_async_A01_t01.dart

@@ -23,44 +23,40 @@
 ///
 /// @author [email protected]
 /// @author [email protected]
+/// @issue 49451
 
 import 'dart:async';
 import '../../../../Utils/expect.dart';
 
 List<int> readyToSent = [];
 List<int> sent = [];
 
-Stream<int> generator(List log) async* {
-  for (int i = 1; i <= 3; i++) {
+Stream<int> generator() async* {
+  for (int i = 1; i <= 5; i++) {
     readyToSent.add(i);
     yield i;
     sent.add(i);
   }
 }
 
-test() async {
+main() async {
+  asyncStart();
   List received = [];
-  Stream<int> s = generator(received);
+  Stream<int> s = generator();
   late StreamSubscription<int> ss;
-  ss = s.listen(
-          (int i) async {
-        received.add(i);
-        if (i == 1) {
-          ss.pause();
-          await Future.delayed(Duration(milliseconds: 100));
-          Expect.listEquals([1], readyToSent);
-          ss.cancel();
-        }
-      }
-  );
+  ss = s.listen((int i) async {
+    received.add(i);
+    if (i == 2) {
+      ss.pause();
+      await Future.delayed(Duration(milliseconds: 100));
+      Expect.listEquals([1], sent);
+      Expect.listEquals([1, 2], readyToSent);
+      await ss.cancel();
+    }
+  });
   await Future.delayed(Duration(seconds: 1));
-  Expect.listEquals([1], received);
+  Expect.listEquals([1, 2], received);
   Expect.listEquals([1], sent);
   Expect.listEquals([1, 2], readyToSent);
   asyncEnd();
 }
-
-main() {
-  asyncStart();
-  test();
-}

Language/Statements/Yield_and_Yield_Each/Yield/execution_async_t02.dart renamed to Language/Statements/Yield_and_Yield_Each/Yield/execution_async_A01_t02.dart

@@ -0,0 +1,57 @@
+// 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 Execution of a statement s of the form yield e; proceeds as
+/// follows:
+///   First, the expression `e` is evaluated to an object `o`. If the enclosing
+/// function `m` is marked `async*` and the stream `u` associated with `m` has
+/// been paused, then the nearest enclosing asynchronous `for` loop if any, is
+/// paused and execution of `m` is suspended until `u` is resumed or canceled.
+///   Next, `o` is added to the iterable or stream associated with the
+/// immediately enclosing function.
+///   If the enclosing function `m` is marked `async*` and the stream `u`
+/// associated with `m` has been canceled, then the `yield` statement returns
+/// without an object, otherwise it completes normally.
+///   Otherwise, if the enclosing function `m` is marked `async*` then the
+/// enclosing function may suspend, in which case the nearest enclosing
+/// asynchronous `for` loop, if any, is paused first.
+///
+/// @description Check that if the enclosing function `m` is marked `async*` and
+/// the stream `u` associated with `m` has been paused, then the nearest
+/// enclosing asynchronous `for` loop is paused and execution of `m` is
+/// suspended until `u` is resumed
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+List<int> readyToSent = [];
+List<int> sent = [];
+
+Stream<int> generator() async* {
+  for (int i = 1; i <= 5; i++) {
+    readyToSent.add(i);
+    yield i;
+    sent.add(i);
+  }
+}
+
+main() async {
+  List<int> received = [];
+  Stream<int> stream = generator();
+  await for (int i in stream) {
+    received.add(i);
+    // We have no access to StreamSubscription here to pause the stream and then
+    // to check that this loop is also pause. So, let's check that the stream is
+    // paused now
+    await Future.delayed(Duration(milliseconds: 100));
+    Expect.listEquals([for (var j = 1; j <= i; j++) j], received);
+    Expect.listEquals([for (var j = 1; j <= i - 1; j++) j], sent);
+    Expect.listEquals([for (var j = 1; j <= i; j++) j], readyToSent);
+  }
+  Expect.listEquals([1, 2, 3, 4, 5], received);
+  Expect.listEquals([1, 2, 3, 4, 5], sent);
+  Expect.listEquals([1, 2, 3, 4, 5], readyToSent);
+}

Language/Statements/Yield_and_Yield_Each/Yield/execution_async_A01_t03.dart

@@ -0,0 +1,60 @@
+// 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 Execution of a statement s of the form yield e; proceeds as
+/// follows:
+///   First, the expression `e` is evaluated to an object `o`. If the enclosing
+/// function `m` is marked `async*` and the stream `u` associated with `m` has
+/// been paused, then the nearest enclosing asynchronous `for` loop if any, is
+/// paused and execution of `m` is suspended until `u` is resumed or canceled.
+///   Next, `o` is added to the iterable or stream associated with the
+/// immediately enclosing function.
+///   If the enclosing function `m` is marked `async*` and the stream `u`
+/// associated with `m` has been canceled, then the `yield` statement returns
+/// without an object, otherwise it completes normally.
+///   Otherwise, if the enclosing function `m` is marked `async*` then the
+/// enclosing function may suspend, in which case the nearest enclosing
+/// asynchronous `for` loop, if any, is paused first.
+///
+/// @description Check that if the enclosing function `m` is marked `async*` and
+/// the stream `u` associated with `m` has been paused, then the nearest
+/// enclosing asynchronous `for` loop is paused and execution of `m` is
+/// suspended until `u` is canceled
+///
+/// @author [email protected]
+/// @issue 49451
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+List<int> readyToSent = [];
+List<int> sent = [];
+
+Stream<int> generator() async* {
+  for (int i = 1; i <= 5; i++) {
+    readyToSent.add(i);
+    yield i;
+    sent.add(i);
+  }
+}
+
+main() async {
+  List<int> received = [];
+  Stream<int> stream = generator();
+  await for (int i in stream) {
+    received.add(i);
+    if (i == 3) {
+      await Future.delayed(Duration(milliseconds: 100));
+      Expect.listEquals([1, 2, 3], received);
+      Expect.listEquals([1, 2], sent);
+      Expect.listEquals([1, 2, 3], readyToSent);
+      // stream is paused now. Let's cancel it
+      break;
+    }
+  }
+  await Future.delayed(Duration(seconds: 1));
+  Expect.listEquals([1, 2, 3], received);
+  Expect.listEquals([1, 2], sent);
+  Expect.listEquals([1, 2, 3], readyToSent);
+}

Language/Statements/Yield_and_Yield_Each/Yield/execution_async_A01_t04.dart

@@ -0,0 +1,50 @@
+// 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 Execution of a statement s of the form yield e; proceeds as
+/// follows:
+///   First, the expression `e` is evaluated to an object `o`. If the enclosing
+/// function `m` is marked `async*` and the stream `u` associated with `m` has
+/// been paused, then the nearest enclosing asynchronous `for` loop if any, is
+/// paused and execution of `m` is suspended until `u` is resumed or canceled.
+///   Next, `o` is added to the iterable or stream associated with the
+/// immediately enclosing function.
+///   If the enclosing function `m` is marked `async*` and the stream `u`
+/// associated with `m` has been canceled, then the `yield` statement returns
+/// without an object, otherwise it completes normally.
+///   Otherwise, if the enclosing function `m` is marked `async*` then the
+/// enclosing function may suspend, in which case the nearest enclosing
+/// asynchronous `for` loop, if any, is paused first.
+///
+/// @description Check that object o is added to stream associated with the
+/// immediately enclosing function.
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator(Iterable<int> iterable) async* {
+  for (var o in iterable) {
+    yield o;
+  }
+}
+
+test() async {
+  List<int> data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+  List<int> log = [];
+  Stream<int> s = generator(data);
+  s.listen(
+      (int x) =>  log.add(x),
+      onDone:() {
+        Expect.listEquals(data, log);
+        asyncEnd();
+      }
+  );
+}
+
+main() {
+  asyncStart();
+  test();
+}

Language/Statements/Yield_and_Yield_Each/Yield/execution_async_A02_t01.dart

@@ -0,0 +1,51 @@
+// 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 Execution of a statement s of the form yield e; proceeds as
+/// follows:
+///   First, the expression `e` is evaluated to an object `o`. If the enclosing
+/// function `m` is marked `async*` and the stream `u` associated with `m` has
+/// been paused, then the nearest enclosing asynchronous `for` loop if any, is
+/// paused and execution of `m` is suspended until `u` is resumed or canceled.
+///   Next, `o` is added to the iterable or stream associated with the
+/// immediately enclosing function.
+///   If the enclosing function `m` is marked `async*` and the stream `u`
+/// associated with `m` has been canceled, then the `yield` statement returns
+/// without an object, otherwise it completes normally.
+///   Otherwise, if the enclosing function `m` is marked `async*` then the
+/// enclosing function may suspend, in which case the nearest enclosing
+/// asynchronous `for` loop, if any, is paused first.
+///
+/// @description Check that if the enclosing function `m` is marked `async*` and
+/// the stream `u`associated with `m` has been canceled, then the `yield`
+/// statement returns without an object, otherwise it completes normally.
+///
+/// @author [email protected]
+
+import 'dart:async';
+import '../../../../Utils/expect.dart';
+
+Stream<int> generator() async* {
+  for (int i = 1; i <= 3; i++) {
+    yield i;
+  }
+}
+
+test() async {
+  List log = [];
+  Stream<int> s = generator();
+  late StreamSubscription<int> ss;
+  ss = s.listen((int i) {
+    log.add(i);
+    ss.cancel();
+  });
+  await Future.delayed(Duration(seconds: 1));
+  Expect.listEquals([1], log);
+  asyncEnd();
+}
+
+main() {
+  asyncStart();
+  test();
+}