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