OLD | NEW |
| (Empty) |
1 // Copyright 2015 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Flags: --harmony-spread-calls | |
6 | |
7 (function testSpreadCallsStrict() { | |
8 "use strict" | |
9 function countArgs() { return arguments.length; } | |
10 | |
11 // Test this argument | |
12 function returnThis() { return this; } | |
13 assertEquals(void 0, returnThis(..."test")); | |
14 | |
15 // Test argument counting with different iterables | |
16 assertEquals(0, countArgs(..."")); | |
17 assertEquals(4, countArgs(..."test")); | |
18 assertEquals(4, countArgs(..."tes", ..."t")); | |
19 assertEquals(4, countArgs("t", ..."es", "t")); | |
20 assertEquals(4, countArgs("tes", ..."t!!")); | |
21 | |
22 assertEquals(1, countArgs(...[1])); | |
23 assertEquals(2, countArgs(...[1, 2])); | |
24 assertEquals(3, countArgs(...[1, 2, 3])); | |
25 assertEquals(4, countArgs(...[1, 2, 3, 4])); | |
26 assertEquals(5, countArgs(...[1, 2, 3, 4, 5])); | |
27 assertEquals(6, countArgs(...[1, 2, 3, 4, 5, 6])); | |
28 | |
29 assertEquals(1, countArgs(...new Set([1]))); | |
30 assertEquals(2, countArgs(...new Set([1, 2]))); | |
31 assertEquals(3, countArgs(...new Set([1, 2, 3]))); | |
32 assertEquals(4, countArgs(...new Set([1, 2, 3, 4]))); | |
33 assertEquals(5, countArgs(...new Set([1, 2, 3, 4, 5]))); | |
34 assertEquals(6, countArgs(...new Set([1, 2, 3, 4, 5, 6]))); | |
35 | |
36 assertEquals(3, countArgs(...(function*(){ yield 1; yield 2; yield 3; })())); | |
37 | |
38 // Test values | |
39 function sum() { | |
40 var sum = arguments[0]; | |
41 for (var i = 1; i < arguments.length; ++i) { | |
42 sum += arguments[i]; | |
43 } | |
44 return sum; | |
45 } | |
46 | |
47 assertEquals(void 0, sum(..."")); | |
48 assertEquals(void 0, sum(...[])); | |
49 assertEquals(void 0, sum(...new Set)); | |
50 assertEquals(void 0, sum(...(function*() { })())); | |
51 | |
52 assertEquals("test", sum(..."test")); | |
53 assertEquals(10, sum(...[1, 2, 3, 4])); | |
54 assertEquals(10, sum(...[1, 2, 3], 4)); | |
55 assertEquals(10, sum(1, ...[2, 3], 4)); | |
56 assertEquals(10, sum(1, ...[2, 3], ...[4])); | |
57 assertEquals(10, sum(1, 2, ...[3, 4])); | |
58 assertEquals(10, sum(...new Set([1, 2, 3, 4]))); | |
59 assertEquals(10, sum(...(function*() { | |
60 yield 1; | |
61 yield 2; | |
62 yield 3; | |
63 yield 4; | |
64 })())); | |
65 | |
66 // nested spreads | |
67 function makeArray() { | |
68 var result = []; | |
69 for (var i = 0; i < arguments.length; ++i) { | |
70 result.push(arguments[i]); | |
71 } | |
72 return result; | |
73 } | |
74 assertEquals(10, sum(...makeArray(...[1, 2, 3, 4]))); | |
75 assertEquals("test!!!", sum(...makeArray(..."test!!!"))); | |
76 | |
77 // Interleaved spread/unspread args | |
78 assertEquals(36, sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8)); | |
79 assertEquals(45, sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8, ...[9])); | |
80 | |
81 // Methods | |
82 var O = { | |
83 returnThis: returnThis, | |
84 countArgs: countArgs, | |
85 sum: sum, | |
86 makeArray: makeArray, | |
87 | |
88 nested: { | |
89 returnThis: returnThis, | |
90 countArgs: countArgs, | |
91 sum: sum, | |
92 makeArray: makeArray | |
93 } | |
94 }; | |
95 | |
96 // Test this argument | |
97 assertEquals(O, O.returnThis(..."test")); | |
98 assertEquals(O, O["returnThis"](..."test")); | |
99 assertEquals(O.nested, O.nested.returnThis(..."test")); | |
100 assertEquals(O.nested, O.nested["returnThis"](..."test")); | |
101 | |
102 // Test argument counting with different iterables | |
103 assertEquals(0, O.countArgs(..."")); | |
104 assertEquals(4, O.countArgs(..."test")); | |
105 assertEquals(4, O.countArgs(..."tes", ..."t")); | |
106 assertEquals(4, O.countArgs("t", ..."es", "t")); | |
107 assertEquals(4, O.countArgs("tes", ..."t!!")); | |
108 | |
109 assertEquals(1, O.countArgs(...[1])); | |
110 assertEquals(2, O.countArgs(...[1, 2])); | |
111 assertEquals(3, O.countArgs(...[1, 2, 3])); | |
112 assertEquals(4, O.countArgs(...[1, 2, 3, 4])); | |
113 assertEquals(5, O.countArgs(...[1, 2, 3, 4, 5])); | |
114 assertEquals(6, O.countArgs(...[1, 2, 3, 4, 5, 6])); | |
115 | |
116 assertEquals(1, O.countArgs(...new Set([1]))); | |
117 assertEquals(2, O.countArgs(...new Set([1, 2]))); | |
118 assertEquals(3, O.countArgs(...new Set([1, 2, 3]))); | |
119 assertEquals(4, O.countArgs(...new Set([1, 2, 3, 4]))); | |
120 assertEquals(5, O.countArgs(...new Set([1, 2, 3, 4, 5]))); | |
121 assertEquals(6, O.countArgs(...new Set([1, 2, 3, 4, 5, 6]))); | |
122 | |
123 assertEquals(3, O.countArgs( | |
124 ...(function*(){ yield 1; yield 2; yield 3; })())); | |
125 | |
126 // Test values | |
127 assertEquals(void 0, O.sum(..."")); | |
128 assertEquals(void 0, O.sum(...[])); | |
129 assertEquals(void 0, O.sum(...new Set)); | |
130 assertEquals(void 0, O.sum(...(function*() { })())); | |
131 | |
132 assertEquals("test", O.sum(..."test")); | |
133 assertEquals(10, O.sum(...[1, 2, 3, 4])); | |
134 assertEquals(10, O.sum(...[1, 2, 3], 4)); | |
135 assertEquals(10, O.sum(1, ...[2, 3], 4)); | |
136 assertEquals(10, O.sum(1, ...[2, 3], ...[4])); | |
137 assertEquals(10, O.sum(1, 2, ...[3, 4])); | |
138 assertEquals(10, O.sum(...new Set([1, 2, 3, 4]))); | |
139 assertEquals(10, O.sum(...(function*() { | |
140 yield 1; | |
141 yield 2; | |
142 yield 3; | |
143 yield 4; | |
144 })())); | |
145 | |
146 // nested spreads | |
147 assertEquals(10, O.sum(...O.makeArray(...[1, 2, 3, 4]))); | |
148 assertEquals("test!!!", O.sum(...O.makeArray(..."test!!!"))); | |
149 | |
150 // Interleaved spread/unspread args | |
151 assertEquals(36, O.sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8)); | |
152 assertEquals(45, O.sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8, ...[9])); | |
153 })(); | |
154 | |
155 | |
156 (function testSpreadCallsSloppy() { | |
157 // Test this argument | |
158 function returnThis() { return this; } | |
159 assertEquals(this, returnThis(..."test")); | |
160 | |
161 function countArgs() { return arguments.length; } | |
162 | |
163 // Test argument counting with different iterables | |
164 assertEquals(0, countArgs(..."")); | |
165 assertEquals(4, countArgs(..."test")); | |
166 assertEquals(4, countArgs(..."tes", ..."t")); | |
167 assertEquals(4, countArgs("t", ..."es", "t")); | |
168 assertEquals(4, countArgs("tes", ..."t!!")); | |
169 | |
170 assertEquals(1, countArgs(...[1])); | |
171 assertEquals(2, countArgs(...[1, 2])); | |
172 assertEquals(3, countArgs(...[1, 2, 3])); | |
173 assertEquals(4, countArgs(...[1, 2, 3, 4])); | |
174 assertEquals(5, countArgs(...[1, 2, 3, 4, 5])); | |
175 assertEquals(6, countArgs(...[1, 2, 3, 4, 5, 6])); | |
176 | |
177 assertEquals(1, countArgs(...new Set([1]))); | |
178 assertEquals(2, countArgs(...new Set([1, 2]))); | |
179 assertEquals(3, countArgs(...new Set([1, 2, 3]))); | |
180 assertEquals(4, countArgs(...new Set([1, 2, 3, 4]))); | |
181 assertEquals(5, countArgs(...new Set([1, 2, 3, 4, 5]))); | |
182 assertEquals(6, countArgs(...new Set([1, 2, 3, 4, 5, 6]))); | |
183 | |
184 assertEquals(3, countArgs(...(function*(){ | |
185 yield 1; | |
186 yield 2; | |
187 yield 3; | |
188 })())); | |
189 | |
190 // Test values | |
191 function sum() { | |
192 var sum = arguments[0]; | |
193 for (var i = 1; i < arguments.length; ++i) { | |
194 sum += arguments[i]; | |
195 } | |
196 return sum; | |
197 } | |
198 | |
199 assertEquals(void 0, sum(..."")); | |
200 assertEquals(void 0, sum(...[])); | |
201 assertEquals(void 0, sum(...new Set)); | |
202 assertEquals(void 0, sum(...(function*() { })())); | |
203 | |
204 assertEquals("test", sum(..."test")); | |
205 assertEquals(10, sum(...[1, 2, 3, 4])); | |
206 assertEquals(10, sum(...[1, 2, 3], 4)); | |
207 assertEquals(10, sum(1, ...[2, 3], 4)); | |
208 assertEquals(10, sum(1, ...[2, 3], ...[4])); | |
209 assertEquals(10, sum(1, 2, ...[3, 4])); | |
210 assertEquals(10, sum(...new Set([1, 2, 3, 4]))); | |
211 assertEquals(10, sum(...(function*() { | |
212 yield 1; | |
213 yield 2; | |
214 yield 3; | |
215 yield 4; | |
216 })())); | |
217 | |
218 // nested spreads | |
219 function makeArray() { | |
220 var result = []; | |
221 for (var i = 0; i < arguments.length; ++i) { | |
222 result.push(arguments[i]); | |
223 } | |
224 return result; | |
225 } | |
226 assertEquals(10, sum(...makeArray(...[1, 2, 3, 4]))); | |
227 assertEquals("test!!!", sum(...makeArray(..."test!!!"))); | |
228 | |
229 // Interleaved spread/unspread args | |
230 assertEquals(36, sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8)); | |
231 assertEquals(45, sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8, ...[9])); | |
232 | |
233 // Methods | |
234 var O = { | |
235 returnThis: returnThis, | |
236 countArgs: countArgs, | |
237 sum: sum, | |
238 makeArray: makeArray, | |
239 | |
240 nested: { | |
241 returnThis: returnThis, | |
242 countArgs: countArgs, | |
243 sum: sum, | |
244 makeArray: makeArray | |
245 } | |
246 }; | |
247 | |
248 // Test this argument | |
249 assertEquals(O, O.returnThis(..."test")); | |
250 assertEquals(O, O["returnThis"](..."test")); | |
251 assertEquals(O.nested, O.nested.returnThis(..."test")); | |
252 assertEquals(O.nested, O.nested["returnThis"](..."test")); | |
253 | |
254 // Test argument counting with different iterables | |
255 assertEquals(0, O.countArgs(..."")); | |
256 assertEquals(4, O.countArgs(..."test")); | |
257 assertEquals(4, O.countArgs(..."tes", ..."t")); | |
258 assertEquals(4, O.countArgs("t", ..."es", "t")); | |
259 assertEquals(4, O.countArgs("tes", ..."t!!")); | |
260 | |
261 assertEquals(1, O.countArgs(...[1])); | |
262 assertEquals(2, O.countArgs(...[1, 2])); | |
263 assertEquals(3, O.countArgs(...[1, 2, 3])); | |
264 assertEquals(4, O.countArgs(...[1, 2, 3, 4])); | |
265 assertEquals(5, O.countArgs(...[1, 2, 3, 4, 5])); | |
266 assertEquals(6, O.countArgs(...[1, 2, 3, 4, 5, 6])); | |
267 | |
268 assertEquals(1, O.countArgs(...new Set([1]))); | |
269 assertEquals(2, O.countArgs(...new Set([1, 2]))); | |
270 assertEquals(3, O.countArgs(...new Set([1, 2, 3]))); | |
271 assertEquals(4, O.countArgs(...new Set([1, 2, 3, 4]))); | |
272 assertEquals(5, O.countArgs(...new Set([1, 2, 3, 4, 5]))); | |
273 assertEquals(6, O.countArgs(...new Set([1, 2, 3, 4, 5, 6]))); | |
274 | |
275 assertEquals(3, O.countArgs(...(function*(){ | |
276 yield 1; | |
277 yield 2; | |
278 yield 3; | |
279 })())); | |
280 | |
281 // Test values | |
282 assertEquals(void 0, O.sum(..."")); | |
283 assertEquals(void 0, O.sum(...[])); | |
284 assertEquals(void 0, O.sum(...new Set)); | |
285 assertEquals(void 0, O.sum(...(function*() { })())); | |
286 | |
287 assertEquals("test", O.sum(..."test")); | |
288 assertEquals(10, O.sum(...[1, 2, 3, 4])); | |
289 assertEquals(10, O.sum(...[1, 2, 3], 4)); | |
290 assertEquals(10, O.sum(1, ...[2, 3], 4)); | |
291 assertEquals(10, O.sum(1, ...[2, 3], ...[4])); | |
292 assertEquals(10, O.sum(1, 2, ...[3, 4])); | |
293 assertEquals(10, O.sum(...new Set([1, 2, 3, 4]))); | |
294 assertEquals(10, O.sum(...(function*() { | |
295 yield 1; | |
296 yield 2; | |
297 yield 3; | |
298 yield 4; | |
299 })())); | |
300 | |
301 // nested spreads | |
302 assertEquals(10, O.sum(...O.makeArray(...[1, 2, 3, 4]))); | |
303 assertEquals("test!!!", O.sum(...O.makeArray(..."test!!!"))); | |
304 | |
305 // Interleaved spread/unspread args | |
306 assertEquals(36, O.sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8)); | |
307 assertEquals(45, O.sum(0, ...[1], 2, 3, ...[4, 5], 6, 7, 8, ...[9])); | |
308 })(); | |
309 | |
310 | |
311 (function testSpreadEvaluationOrder() { | |
312 "use strict"; | |
313 var log = ""; | |
314 function* gen() { log += "X"; yield 0; log += "Y"; } | |
315 function a() { log += "A"; } | |
316 function b() { log += "B"; return gen(); } | |
317 function* c() { log += 'C1'; yield 1; log += 'C2'; } | |
318 function d() { log += "D"; } | |
319 function e() { log += "E"; } | |
320 function fn() { | |
321 var args = []; | |
322 for (var i = 0; i < arguments.length; ++i) args.push(arguments[i]); | |
323 return args; | |
324 } | |
325 | |
326 var result = fn(a(), ...b(), d()); | |
327 assertEquals([undefined, 0, undefined], result); | |
328 assertEquals("ABXYD", log); | |
329 | |
330 log = ""; | |
331 result = fn(...b(), d()); | |
332 assertEquals([0, undefined], result); | |
333 assertEquals("BXYD", log); | |
334 | |
335 log = ""; | |
336 result = fn(a(), ...b()); | |
337 assertEquals([undefined, 0], result); | |
338 assertEquals("ABXY", log); | |
339 | |
340 log = ""; | |
341 result = fn(a(), ...b(), ...c(), d(), e()); | |
342 assertEquals([undefined, 0, 1, undefined, undefined], result); | |
343 assertEquals("ABXYC1C2DE", log); | |
344 | |
345 log = ""; | |
346 result = fn(a(), ...b(), ...c(), d(), e(), ...b(), ...c()); | |
347 assertEquals([undefined, 0, 1, undefined, undefined, 0, 1], result); | |
348 assertEquals("ABXYC1C2DEBXYC1C2", log); | |
349 })(); | |
350 | |
351 | |
352 (function testCustomArrayPrototypeIterator() { | |
353 var origIterator = | |
354 Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator); | |
355 Object.defineProperty(Array.prototype, Symbol.iterator, { | |
356 value: function*() { | |
357 yield 1; | |
358 yield 2; | |
359 yield 3; | |
360 }, | |
361 configurable: true | |
362 }); | |
363 function returnCountStrict() { 'use strict'; return arguments.length; } | |
364 function returnCountSloppy() { return arguments.length; } | |
365 | |
366 assertEquals(3, returnCountStrict(...[1])); | |
367 assertEquals(4, returnCountStrict(1, ...[2])); | |
368 assertEquals(5, returnCountStrict(1, ...[2], 3)); | |
369 assertEquals(3, returnCountSloppy(...[1])); | |
370 assertEquals(4, returnCountSloppy(1, ...[2])); | |
371 assertEquals(5, returnCountSloppy(1, ...[2], 3)); | |
372 | |
373 Object.defineProperty(Array.prototype, Symbol.iterator, origIterator); | |
374 })(); | |
OLD | NEW |