[JSC] AI should not propagate AbstractValue relying on constant folding phase
[WebKit-https.git] / JSTests / stress / async-iteration-for-await-of.js
1 var assert = function (result, expected, message = "") {
2   if (result !== expected) {
3     throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
4   }
5 };
6 var result = 0;
7 async function * foo() { yield 1; yield Promise.resolve(2); return 3;};
8
9 async function boo () {
10     for await (const value of foo()) {
11         result = result + value;
12     }
13 }
14
15 boo();
16
17 drainMicrotasks();
18
19 assert(result, 3);
20
21 result =  0;
22
23 {
24     const boo =  async function () {
25         for await (const val of foo()) {
26             result = result + val;
27         }
28     }
29
30     boo();
31
32     drainMicrotasks();
33
34     assert(result, 3);
35 }
36
37 {
38     result =  0;
39     const boo = async function () {
40         for await (const val of [1, 2, 3]) {
41             result = result + val;
42         }
43     }
44
45     boo();
46
47     drainMicrotasks();
48
49     assert(result, 6);
50 }
51
52
53     let error = false;
54
55     const boo = async function () {
56         for await (const val of 1) {
57             result = result + val;
58         }
59     }
60
61     boo().catch(raisedError => error = raisedError instanceof TypeError);
62
63     drainMicrotasks();
64
65     assert(error, true);
66 }
67
68 {
69     let conter = 0;
70     const o = {
71         [Symbol.asyncIterator]() {
72             return this
73         },
74         next(args) {
75             return { done: true }
76         }
77     }
78
79     result = -1;
80     const boo = async function () {
81         for await (const val of o) {
82             conter++;
83             result = val;
84         }
85     }
86
87     boo();
88
89     drainMicrotasks();
90
91     assert(conter, 0);
92     assert(result, -1);
93 }
94
95 {
96     let conter = 0;
97     const o = {
98         [Symbol.asyncIterator]() {
99             this.index = 0;
100             return this
101         },
102         next(args) {
103             this.index++;
104             if (this.index <= 10)
105                 return { done: false, value: this.index };
106             else 
107                 return { done: true, value: this.index };
108         }
109     }
110
111     result = 0;
112     const boo = async function () {
113         for await (const val of o) {
114             conter++;
115             result += val;
116         }
117     }
118
119     boo();
120
121     drainMicrotasks();
122
123     assert(conter, 10);
124     assert(result, 55);
125 }
126
127 {
128     let conter = 0;
129     let error = false;
130
131     const o = {
132         [Symbol.asyncIterator]() {
133             this.index = 0;
134             return this
135         },
136         next(args) {
137             this.index++;
138             if (this.index <= 10)
139                 return { done: false, value: this.index };
140             else 
141                 throw new Error('some error');
142         }
143     }
144
145     result = 0;
146     const boo = async function () {
147         for await (const val of o) {
148             conter++;
149             result += val;
150         }
151     }
152
153     boo().catch(e => { error = e instanceof Error && e.message === 'some error'; });
154
155     drainMicrotasks();
156
157     assert(conter, 10);
158     assert(result, 55);
159     assert(error, true);
160 }
161
162 {
163     let conter = 0;
164     let error = false;
165     let emptyParam = false;
166
167     const o = {
168         [Symbol.asyncIterator]() {
169             this.index = 0;
170             return this
171         },
172         next(args) {
173             emptyParam = args === undefined;
174             this.index++;
175             if (this.index <= 10)
176                 return { done: false, value: this.index };
177             else 
178                 throw new Error('some error');
179         }
180     }
181
182     result = 0;
183     const boo = async function () {
184         try {
185             for await (const val of o) {
186                 conter++;
187                 result += val;
188             }
189         } catch (e) {
190             error =  e instanceof Error && e.message === 'some error';
191         }
192     }
193
194     boo();
195
196     drainMicrotasks();
197
198     assert(conter, 10);
199     assert(result, 55);
200     assert(error, true);
201     assert(emptyParam, true);
202 }
203
204 {
205     let conter = 0;
206     let error = false;
207
208     const o = {
209         [Symbol.asyncIterator]() {
210             this.index = 0;
211             return this
212         },
213         next(args) {
214             this.index++;
215             if (this.index <= 10)
216                 return { done: false, value: this.index };
217             else 
218                 return { done: true, value: this.index };
219         }
220     }
221
222     result = 0;
223     const boo = async function () {
224         if (true) {
225             for await (const val of o) {
226                 conter++;
227                 result += val;
228             }
229         }
230     }
231
232     boo();
233
234     drainMicrotasks();
235
236     assert(conter, 10);
237     assert(result, 55);
238 }
239
240 {
241     let conter = 0;
242     let error = false;
243     let emptyParam = false;
244
245     const o = {
246         [Symbol.iterator]() {
247             this.index = 0;
248             return this
249         },
250         next(args) {
251             emptyParam = args === undefined;
252             this.index++;
253             if (this.index <= 10)
254                 return { done: false, value: this.index };
255             else 
256                 throw new Error('some error');
257         }
258     }
259
260     result = 0;
261     const boo = async function () {
262         try {
263             for await (const val of o) {
264                 conter++;
265                 result += val;
266             }
267         } catch (e) {
268             error =  e instanceof Error && e.message === 'some error';
269         }
270     }
271
272     boo();
273
274     drainMicrotasks();
275
276     assert(conter, 10);
277     assert(result, 55);
278     assert(error, true);
279     assert(emptyParam, true);
280 }