Line data Source code
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 : #include <fstream>
6 :
7 : #include "src/v8.h"
8 :
9 : #include "src/interpreter/bytecode-array-iterator.h"
10 : #include "src/interpreter/bytecode-generator.h"
11 : #include "src/interpreter/interpreter.h"
12 : #include "src/objects-inl.h"
13 : #include "test/cctest/cctest.h"
14 : #include "test/cctest/interpreter/bytecode-expectations-printer.h"
15 : #include "test/cctest/test-feedback-vector.h"
16 :
17 : namespace v8 {
18 : namespace internal {
19 : namespace interpreter {
20 :
21 : #define XSTR(A) #A
22 : #define STR(A) XSTR(A)
23 :
24 : #define UNIQUE_VAR() "var a" STR(__COUNTER__) " = 0;\n"
25 :
26 : #define REPEAT_2(...) __VA_ARGS__ __VA_ARGS__
27 : #define REPEAT_4(...) REPEAT_2(__VA_ARGS__) REPEAT_2(__VA_ARGS__)
28 : #define REPEAT_8(...) REPEAT_4(__VA_ARGS__) REPEAT_4(__VA_ARGS__)
29 : #define REPEAT_16(...) REPEAT_8(__VA_ARGS__) REPEAT_8(__VA_ARGS__)
30 : #define REPEAT_32(...) REPEAT_16(__VA_ARGS__) REPEAT_16(__VA_ARGS__)
31 : #define REPEAT_64(...) REPEAT_32(__VA_ARGS__) REPEAT_32(__VA_ARGS__)
32 : #define REPEAT_128(...) REPEAT_64(__VA_ARGS__) REPEAT_64(__VA_ARGS__)
33 : #define REPEAT_256(...) REPEAT_128(__VA_ARGS__) REPEAT_128(__VA_ARGS__)
34 :
35 : #define REPEAT_127(...) \
36 : REPEAT_64(__VA_ARGS__) \
37 : REPEAT_32(__VA_ARGS__) \
38 : REPEAT_16(__VA_ARGS__) \
39 : REPEAT_8(__VA_ARGS__) \
40 : REPEAT_4(__VA_ARGS__) \
41 : REPEAT_2(__VA_ARGS__) \
42 : __VA_ARGS__
43 :
44 : #define REPEAT_249(...) \
45 : REPEAT_127(__VA_ARGS__) \
46 : REPEAT_64(__VA_ARGS__) \
47 : REPEAT_32(__VA_ARGS__) \
48 : REPEAT_16(__VA_ARGS__) \
49 : REPEAT_8(__VA_ARGS__) \
50 : REPEAT_2(__VA_ARGS__)
51 :
52 : #define REPEAT_2_UNIQUE_VARS() UNIQUE_VAR() UNIQUE_VAR()
53 : #define REPEAT_4_UNIQUE_VARS() REPEAT_2_UNIQUE_VARS() REPEAT_2_UNIQUE_VARS()
54 : #define REPEAT_8_UNIQUE_VARS() REPEAT_4_UNIQUE_VARS() REPEAT_4_UNIQUE_VARS()
55 : #define REPEAT_16_UNIQUE_VARS() REPEAT_8_UNIQUE_VARS() REPEAT_8_UNIQUE_VARS()
56 : #define REPEAT_32_UNIQUE_VARS() REPEAT_16_UNIQUE_VARS() REPEAT_16_UNIQUE_VARS()
57 : #define REPEAT_64_UNIQUE_VARS() REPEAT_32_UNIQUE_VARS() REPEAT_32_UNIQUE_VARS()
58 : #define REPEAT_128_UNIQUE_VARS() REPEAT_64_UNIQUE_VARS() REPEAT_64_UNIQUE_VARS()
59 :
60 : #define REPEAT_250_UNIQUE_VARS() \
61 : REPEAT_128_UNIQUE_VARS() \
62 : REPEAT_64_UNIQUE_VARS() \
63 : REPEAT_32_UNIQUE_VARS() \
64 : REPEAT_16_UNIQUE_VARS() \
65 : REPEAT_8_UNIQUE_VARS() \
66 : UNIQUE_VAR() \
67 : UNIQUE_VAR()
68 :
69 : static const char* kGoldenFileDirectory =
70 : "test/cctest/interpreter/bytecode_expectations/";
71 :
72 498 : class InitializedIgnitionHandleScope : public InitializedHandleScope {
73 : public:
74 498 : InitializedIgnitionHandleScope() {
75 498 : i::FLAG_always_opt = false;
76 498 : i::FLAG_allow_natives_syntax = true;
77 : }
78 : };
79 :
80 498 : void SkipGoldenFileHeader(std::istream& stream) { // NOLINT
81 : std::string line;
82 : int separators_seen = 0;
83 8910 : while (std::getline(stream, line)) {
84 4206 : if (line == "---") separators_seen += 1;
85 4704 : if (separators_seen == 2) return;
86 : }
87 : }
88 :
89 498 : std::string LoadGolden(const std::string& golden_filename) {
90 1494 : std::ifstream expected_file((kGoldenFileDirectory + golden_filename).c_str());
91 498 : CHECK(expected_file.is_open());
92 498 : SkipGoldenFileHeader(expected_file);
93 996 : std::ostringstream expected_stream;
94 : // Restore the first separator, which was consumed by SkipGoldenFileHeader
95 498 : expected_stream << "---\n" << expected_file.rdbuf();
96 498 : return expected_stream.str();
97 : }
98 :
99 : template <size_t N>
100 498 : std::string BuildActual(const BytecodeExpectationsPrinter& printer,
101 : const char* (&snippet_list)[N],
102 : const char* prologue = nullptr,
103 : const char* epilogue = nullptr) {
104 498 : std::ostringstream actual_stream;
105 3054 : for (const char* snippet : snippet_list) {
106 : std::string source_code;
107 2556 : if (prologue) source_code += prologue;
108 : source_code += snippet;
109 2556 : if (epilogue) source_code += epilogue;
110 2556 : printer.PrintExpectation(actual_stream, source_code);
111 : }
112 498 : return actual_stream.str();
113 : }
114 :
115 498 : bool CompareTexts(const std::string& generated, const std::string& expected) {
116 498 : std::istringstream generated_stream(generated);
117 996 : std::istringstream expected_stream(expected);
118 : std::string generated_line;
119 : std::string expected_line;
120 : // Line number does not include golden file header.
121 : int line_number = 0;
122 :
123 : do {
124 191334 : std::getline(generated_stream, generated_line);
125 191334 : std::getline(expected_stream, expected_line);
126 :
127 191832 : if (!generated_stream.good() && !expected_stream.good()) {
128 : return true;
129 : }
130 :
131 190836 : if (!generated_stream.good()) {
132 0 : std::cerr << "Expected has extra lines after line " << line_number
133 0 : << "\n";
134 0 : std::cerr << " Expected: '" << expected_line << "'\n";
135 0 : return false;
136 190836 : } else if (!expected_stream.good()) {
137 0 : std::cerr << "Generated has extra lines after line " << line_number
138 0 : << "\n";
139 0 : std::cerr << " Generated: '" << generated_line << "'\n";
140 0 : return false;
141 : }
142 :
143 190836 : if (generated_line != expected_line) {
144 0 : std::cerr << "Inputs differ at line " << line_number << "\n";
145 0 : std::cerr << " Generated: '" << generated_line << "'\n";
146 0 : std::cerr << " Expected: '" << expected_line << "'\n";
147 0 : return false;
148 : }
149 190836 : line_number++;
150 498 : } while (true);
151 : }
152 :
153 23724 : TEST(PrimitiveReturnStatements) {
154 : InitializedIgnitionHandleScope scope;
155 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
156 : const char* snippets[] = {
157 : "",
158 :
159 : "return;\n",
160 :
161 : "return null;\n",
162 :
163 : "return true;\n",
164 :
165 : "return false;\n",
166 :
167 : "return 0;\n",
168 :
169 : "return +1;\n",
170 :
171 : "return -1;\n",
172 :
173 : "return +127;\n",
174 :
175 : "return -128;\n",
176 :
177 : "return 2.0;\n",
178 6 : };
179 :
180 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
181 : LoadGolden("PrimitiveReturnStatements.golden")));
182 6 : }
183 :
184 23724 : TEST(PrimitiveExpressions) {
185 : InitializedIgnitionHandleScope scope;
186 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
187 : const char* snippets[] = {
188 : "var x = 0; return x;\n",
189 :
190 : "var x = 0; return x + 3;\n",
191 :
192 : "var x = 0; return 3 + x;\n",
193 :
194 : "var x = 0; return x - 3;\n",
195 :
196 : "var x = 0; return 3 - x;\n",
197 :
198 : "var x = 4; return x * 3;\n",
199 :
200 : "var x = 4; return 3 * x;\n",
201 :
202 : "var x = 4; return x / 3;\n",
203 :
204 : "var x = 4; return 3 / x;\n",
205 :
206 : "var x = 4; return x % 3;\n",
207 :
208 : "var x = 4; return 3 % x;\n",
209 :
210 : "var x = 1; return x | 2;\n",
211 :
212 : "var x = 1; return 2 | x;\n",
213 :
214 : "var x = 1; return x ^ 2;\n",
215 :
216 : "var x = 1; return 2 ^ x;\n",
217 :
218 : "var x = 1; return x & 2;\n",
219 :
220 : "var x = 1; return 2 & x;\n",
221 :
222 : "var x = 10; return x << 3;\n",
223 :
224 : "var x = 10; return 3 << x;\n",
225 :
226 : "var x = 10; return x >> 3;\n",
227 :
228 : "var x = 10; return 3 >> x;\n",
229 :
230 : "var x = 10; return x >>> 3;\n",
231 :
232 : "var x = 10; return 3 >>> x;\n",
233 :
234 : "var x = 0; return (x, 3);\n",
235 6 : };
236 :
237 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
238 : LoadGolden("PrimitiveExpressions.golden")));
239 6 : }
240 :
241 23724 : TEST(LogicalExpressions) {
242 : InitializedIgnitionHandleScope scope;
243 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
244 : const char* snippets[] = {
245 : "var x = 0; return x || 3;\n",
246 :
247 : "var x = 0; return (x == 1) || 3;\n",
248 :
249 : "var x = 0; return x && 3;\n",
250 :
251 : "var x = 0; return (x == 0) && 3;\n",
252 :
253 : "var x = 0; return x || (1, 2, 3);\n",
254 :
255 : "var a = 2, b = 3, c = 4; return a || (a, b, a, b, c = 5, 3);\n",
256 :
257 : "var x = 1; var a = 2, b = 3; return x || (" //
258 : REPEAT_32("\n a = 1, b = 2, ") //
259 : "3);\n",
260 :
261 : "var x = 0; var a = 2, b = 3; return x && (" //
262 : REPEAT_32("\n a = 1, b = 2, ") //
263 : "3);\n",
264 :
265 : "var x = 1; var a = 2, b = 3; return (x > 3) || (" //
266 : REPEAT_32("\n a = 1, b = 2, ") //
267 : "3);\n",
268 :
269 : "var x = 0; var a = 2, b = 3; return (x < 5) && (" //
270 : REPEAT_32("\n a = 1, b = 2, ") //
271 : "3);\n",
272 :
273 : "return 0 && 3;\n",
274 :
275 : "return 1 || 3;\n",
276 :
277 : "var x = 1; return x && 3 || 0, 1;\n",
278 6 : };
279 :
280 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
281 : LoadGolden("LogicalExpressions.golden")));
282 6 : }
283 :
284 23724 : TEST(Parameters) {
285 : InitializedIgnitionHandleScope scope;
286 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
287 : printer.set_wrap(false);
288 12 : printer.set_test_function_name("f");
289 :
290 : const char* snippets[] = {
291 : "function f() { return this; }",
292 :
293 : "function f(arg1) { return arg1; }",
294 :
295 : "function f(arg1) { return this; }",
296 :
297 : "function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return arg4; }",
298 :
299 : "function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return this; }",
300 :
301 : "function f(arg1) { arg1 = 1; }",
302 :
303 : "function f(arg1, arg2, arg3, arg4) { arg2 = 1; }",
304 6 : };
305 :
306 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
307 : LoadGolden("Parameters.golden")));
308 6 : }
309 :
310 23724 : TEST(IntegerConstants) {
311 : InitializedIgnitionHandleScope scope;
312 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
313 : const char* snippets[] = {
314 : "return 12345678;\n",
315 :
316 : "var a = 1234; return 5678;\n",
317 :
318 : "var a = 1234; return 1234;\n",
319 6 : };
320 :
321 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
322 : LoadGolden("IntegerConstants.golden")));
323 6 : }
324 :
325 23724 : TEST(HeapNumberConstants) {
326 : InitializedIgnitionHandleScope scope;
327 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
328 : const char* snippets[] = {
329 : "return 1.2;\n",
330 :
331 : "var a = 1.2; return 2.6;\n",
332 :
333 : "var a = 3.14; return 3.14;\n",
334 :
335 : "var a;" //
336 : REPEAT_256("\na = 1.414;") //
337 : " a = 3.14;\n",
338 6 : };
339 :
340 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
341 : LoadGolden("HeapNumberConstants.golden")));
342 6 : }
343 :
344 23724 : TEST(StringConstants) {
345 : InitializedIgnitionHandleScope scope;
346 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
347 : const char* snippets[] = {
348 : "return \"This is a string\";\n",
349 :
350 : "var a = \"First string\"; return \"Second string\";\n",
351 :
352 : "var a = \"Same string\"; return \"Same string\";\n",
353 6 : };
354 :
355 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
356 : LoadGolden("StringConstants.golden")));
357 6 : }
358 :
359 23724 : TEST(PropertyLoads) {
360 : InitializedIgnitionHandleScope scope;
361 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
362 : printer.set_wrap(false);
363 12 : printer.set_test_function_name("f");
364 :
365 : const char* snippets[] = {
366 : "function f(a) { return a.name; }\n"
367 : "f({name : \"test\"});\n",
368 :
369 : "function f(a) { return a[\"key\"]; }\n"
370 : "f({key : \"test\"});\n",
371 :
372 : "function f(a) { return a[100]; }\n"
373 : "f({100 : \"test\"});\n",
374 :
375 : "function f(a, b) { return a[b]; }\n"
376 : "f({arg : \"test\"}, \"arg\");\n",
377 :
378 : "function f(a) { var b = a.name; return a[-124]; }\n"
379 : "f({\"-124\" : \"test\", name : 123 })",
380 :
381 : "function f(a) {\n"
382 : " var b;\n"
383 : " b = a.name;\n"
384 : REPEAT_127(" b = a.name;\n")
385 : " return a.name;\n"
386 : "}\n"
387 : "f({name : \"test\"})\n",
388 :
389 : "function f(a, b) {\n"
390 : " var c;\n"
391 : " c = a[b];\n"
392 : REPEAT_127(" c = a[b];\n")
393 : " return a[b];\n"
394 : "}\n"
395 : "f({name : \"test\"}, \"name\")\n",
396 6 : };
397 :
398 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
399 : LoadGolden("PropertyLoads.golden")));
400 6 : }
401 :
402 23724 : TEST(PropertyStores) {
403 : InitializedIgnitionHandleScope scope;
404 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
405 : printer.set_wrap(false);
406 12 : printer.set_test_function_name("f");
407 :
408 : const char* snippets[] = {
409 : "function f(a) { a.name = \"val\"; }\n"
410 : "f({name : \"test\"})",
411 :
412 : "function f(a) { a[\"key\"] = \"val\"; }\n"
413 : "f({key : \"test\"})",
414 :
415 : "function f(a) { a[100] = \"val\"; }\n"
416 : "f({100 : \"test\"})",
417 :
418 : "function f(a, b) { a[b] = \"val\"; }\n"
419 : "f({arg : \"test\"}, \"arg\")",
420 :
421 : "function f(a) { a.name = a[-124]; }\n"
422 : "f({\"-124\" : \"test\", name : 123 })",
423 :
424 : "function f(a) { \"use strict\"; a.name = \"val\"; }\n"
425 : "f({name : \"test\"})",
426 :
427 : "function f(a, b) { \"use strict\"; a[b] = \"val\"; }\n"
428 : "f({arg : \"test\"}, \"arg\")",
429 :
430 : "function f(a) {\n"
431 : " a.name = 1;\n"
432 : REPEAT_127(" a.name = 1;\n")
433 : " a.name = 2;\n"
434 : "}\n"
435 : "f({name : \"test\"})\n",
436 :
437 : "function f(a) {\n"
438 : " 'use strict';\n"
439 : " a.name = 1;\n"
440 : REPEAT_127(" a.name = 1;\n")
441 : " a.name = 2;\n"
442 : "}\n"
443 : "f({name : \"test\"})\n",
444 :
445 : "function f(a, b) {\n"
446 : " a[b] = 1;\n"
447 : REPEAT_127(" a[b] = 1;\n")
448 : " a[b] = 2;\n"
449 : "}\n"
450 : "f({name : \"test\"})\n",
451 :
452 : "function f(a, b) {\n"
453 : " 'use strict';\n"
454 : " a[b] = 1;\n"
455 : REPEAT_127(" a[b] = 1;\n")
456 : " a[b] = 2;\n"
457 : "}\n"
458 : "f({name : \"test\"})\n",
459 6 : };
460 :
461 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
462 : LoadGolden("PropertyStores.golden")));
463 6 : }
464 :
465 : #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
466 :
467 23724 : TEST(PropertyCall) {
468 : InitializedIgnitionHandleScope scope;
469 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
470 : printer.set_wrap(false);
471 12 : printer.set_test_function_name("f");
472 :
473 : const char* snippets[] = {
474 : "function f(a) { return a.func(); }\n"
475 : "f(" FUNC_ARG ")",
476 :
477 : "function f(a, b, c) { return a.func(b, c); }\n"
478 : "f(" FUNC_ARG ", 1, 2)",
479 :
480 : "function f(a, b) { return a.func(b + b, b); }\n"
481 : "f(" FUNC_ARG ", 1)",
482 :
483 : "function f(a) {\n"
484 : " a.func;\n" //
485 : REPEAT_127(" a.func;\n") //
486 : " return a.func(); }\n"
487 : "f(" FUNC_ARG ")",
488 :
489 : "function f(a) { return a.func(1).func(2).func(3); }\n"
490 : "f(new (function Obj() { this.func = function(a) { return this; }})())",
491 6 : };
492 :
493 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
494 : LoadGolden("PropertyCall.golden")));
495 6 : }
496 :
497 23724 : TEST(LoadGlobal) {
498 : InitializedIgnitionHandleScope scope;
499 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
500 : printer.set_wrap(false);
501 12 : printer.set_test_function_name("f");
502 :
503 : const char* snippets[] = {
504 : "var a = 1;\n"
505 : "function f() { return a; }\n"
506 : "f()",
507 :
508 : "function t() { }\n"
509 : "function f() { return t; }\n"
510 : "f()",
511 :
512 : "a = 1;\n"
513 : "function f() { return a; }\n"
514 : "f()",
515 :
516 : "a = 1;\n"
517 : "function f(b) {\n"
518 : " b.name;\n"
519 : REPEAT_127(" b.name;\n")
520 : " return a;\n"
521 : "}\n"
522 : "f({name: 1});\n",
523 6 : };
524 :
525 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
526 : LoadGolden("LoadGlobal.golden")));
527 6 : }
528 :
529 23724 : TEST(StoreGlobal) {
530 : InitializedIgnitionHandleScope scope;
531 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
532 : printer.set_wrap(false);
533 12 : printer.set_test_function_name("f");
534 :
535 : const char* snippets[] = {
536 : "var a = 1;\n"
537 : "function f() { a = 2; }\n"
538 : "f();\n",
539 :
540 : "var a = \"test\"; function f(b) { a = b; }\n"
541 : "f(\"global\");\n",
542 :
543 : "'use strict'; var a = 1;\n"
544 : "function f() { a = 2; }\n"
545 : "f();\n",
546 :
547 : "a = 1;\n"
548 : "function f() { a = 2; }\n"
549 : "f();\n",
550 :
551 : "a = 1;\n"
552 : "function f(b) {\n"
553 : " b.name;\n"
554 : REPEAT_127(" b.name;\n")
555 : " a = 2;\n"
556 : "}\n"
557 : "f({name: 1});\n",
558 :
559 : "a = 1;\n"
560 : "function f(b) {\n"
561 : " 'use strict';\n"
562 : " b.name;\n"
563 : REPEAT_127(" b.name;\n")
564 : " a = 2;\n"
565 : "}\n"
566 : "f({name: 1});\n",
567 6 : };
568 :
569 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
570 : LoadGolden("StoreGlobal.golden")));
571 6 : }
572 :
573 23724 : TEST(CallGlobal) {
574 : InitializedIgnitionHandleScope scope;
575 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
576 : printer.set_wrap(false);
577 12 : printer.set_test_function_name("f");
578 :
579 : const char* snippets[] = {
580 : "function t() { }\n"
581 : "function f() { return t(); }\n"
582 : "f();\n",
583 :
584 : "function t(a, b, c) { }\n"
585 : "function f() { return t(1, 2, 3); }\n"
586 : "f();\n",
587 6 : };
588 :
589 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
590 : LoadGolden("CallGlobal.golden")));
591 6 : }
592 :
593 23724 : TEST(CallRuntime) {
594 : InitializedIgnitionHandleScope scope;
595 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
596 : printer.set_wrap(false);
597 12 : printer.set_test_function_name("f");
598 :
599 : const char* snippets[] = {
600 : "function f() { %TheHole() }\n"
601 : "f();\n",
602 :
603 : "function f(a) { return %IsArray(a) }\n"
604 : "f(undefined);\n",
605 :
606 : "function f() { return %Add(1, 2) }\n"
607 : "f();\n",
608 :
609 : "function f() { return %spread_iterable([1]) }\n"
610 : "f();\n",
611 6 : };
612 :
613 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
614 : LoadGolden("CallRuntime.golden")));
615 6 : }
616 :
617 23724 : TEST(IfConditions) {
618 : InitializedIgnitionHandleScope scope;
619 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
620 : printer.set_wrap(false);
621 12 : printer.set_test_function_name("f");
622 :
623 : const char* snippets[] = {
624 : "function f() {\n"
625 : " if (0) {\n"
626 : " return 1;\n"
627 : " } else {\n"
628 : " return -1;\n"
629 : " }\n"
630 : "};\n"
631 : "f();\n",
632 :
633 : "function f() {\n"
634 : " if ('lucky') {\n"
635 : " return 1;\n"
636 : " } else {\n"
637 : " return -1;\n"
638 : " }\n"
639 : "};\n"
640 : "f();\n",
641 :
642 : "function f() {\n"
643 : " if (false) {\n"
644 : " return 1;\n"
645 : " } else {\n"
646 : " return -1;\n"
647 : " }\n"
648 : "};\n"
649 : "f();\n",
650 :
651 : "function f() {\n"
652 : " if (false) {\n"
653 : " return 1;\n"
654 : " }\n"
655 : "};\n"
656 : "f();\n",
657 :
658 : "function f() {\n"
659 : " var a = 1;\n"
660 : " if (a) {\n"
661 : " a += 1;\n"
662 : " } else {\n"
663 : " return 2;\n"
664 : " }\n"
665 : "};\n"
666 : "f();\n",
667 :
668 : "function f(a) {\n"
669 : " if (a <= 0) {\n"
670 : " return 200;\n"
671 : " } else {\n"
672 : " return -200;\n"
673 : " }\n"
674 : "};\n"
675 : "f(99);\n",
676 :
677 : "function f(a, b) { if (a in b) { return 200; } }"
678 : "f('prop', { prop: 'yes'});\n",
679 :
680 : "function f(z) { var a = 0; var b = 0; if (a === 0.01) {\n"
681 : REPEAT_64(" b = a; a = b;\n")
682 : " return 200; } else { return -200; } } f(0.001);\n",
683 :
684 : "function f() {\n"
685 : " var a = 0; var b = 0;\n"
686 : " if (a) {\n"
687 : REPEAT_64(" b = a; a = b;\n")
688 : " return 200; } else { return -200; }\n"
689 : "};\n"
690 : "f();\n",
691 :
692 : "function f(a, b) {\n"
693 : " if (a == b) { return 1; }\n"
694 : " if (a === b) { return 1; }\n"
695 : " if (a < b) { return 1; }\n"
696 : " if (a > b) { return 1; }\n"
697 : " if (a <= b) { return 1; }\n"
698 : " if (a >= b) { return 1; }\n"
699 : " if (a in b) { return 1; }\n"
700 : " if (a instanceof b) { return 1; }\n"
701 : " return 0;\n"
702 : "}\n"
703 : "f(1, 1);\n",
704 :
705 : "function f() {\n"
706 : " var a = 0;\n"
707 : " if (a) {\n"
708 : " return 20;\n"
709 : " } else {\n"
710 : " return -20;\n"
711 : " }\n"
712 : "};\n"
713 : "f();\n",
714 :
715 : "function f(a, b) {\n"
716 : " if (a == b || a < 0) {\n"
717 : " return 1;\n"
718 : " } else if (a > 0 && b > 0) {\n"
719 : " return 0;\n"
720 : " } else {\n"
721 : " return -1;\n"
722 : " }\n"
723 : "};\n"
724 : "f(-1, 1);\n",
725 6 : };
726 :
727 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
728 : LoadGolden("IfConditions.golden")));
729 6 : }
730 :
731 23724 : TEST(DeclareGlobals) {
732 : InitializedIgnitionHandleScope scope;
733 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
734 : printer.set_wrap(false);
735 12 : printer.set_test_function_name("f");
736 : printer.set_top_level(true);
737 :
738 : const char* snippets[] = {
739 : "var a = 1;\n",
740 :
741 : "function f() {}\n",
742 :
743 : "var a = 1;\n"
744 : "a=2;\n",
745 :
746 : "function f() {}\n"
747 : "f();\n",
748 6 : };
749 :
750 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
751 : LoadGolden("DeclareGlobals.golden")));
752 6 : }
753 :
754 23724 : TEST(BreakableBlocks) {
755 : InitializedIgnitionHandleScope scope;
756 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
757 :
758 : const char* snippets[] = {
759 : "var x = 0;\n"
760 : "label: {\n"
761 : " x = x + 1;\n"
762 : " break label;\n"
763 : " x = x + 1;\n"
764 : "}\n"
765 : "return x;\n",
766 :
767 : "var sum = 0;\n"
768 : "outer: {\n"
769 : " for (var x = 0; x < 10; ++x) {\n"
770 : " for (var y = 0; y < 3; ++y) {\n"
771 : " ++sum;\n"
772 : " if (x + y == 12) { break outer; }\n"
773 : " }\n"
774 : " }\n"
775 : "}\n"
776 : "return sum;\n",
777 :
778 : "outer: {\n"
779 : " let y = 10;\n"
780 : " function f() { return y; }\n"
781 : " break outer;\n"
782 : "}\n",
783 :
784 : "let x = 1;\n"
785 : "outer: {\n"
786 : " inner: {\n"
787 : " let y = 2;\n"
788 : " function f() { return x + y; }\n"
789 : " if (y) break outer;\n"
790 : " y = 3;\n"
791 : " }\n"
792 : "}\n"
793 : "x = 4;\n",
794 6 : };
795 :
796 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
797 : LoadGolden("BreakableBlocks.golden")));
798 6 : }
799 :
800 23724 : TEST(BasicLoops) {
801 : InitializedIgnitionHandleScope scope;
802 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
803 : const char* snippets[] = {
804 : "var x = 0;\n"
805 : "while (false) { x = 99; break; continue; }\n"
806 : "return x;\n",
807 :
808 : "var x = 0;\n"
809 : "while (false) {\n"
810 : " x = x + 1;\n"
811 : "};\n"
812 : "return x;\n",
813 :
814 : "var x = 0;\n"
815 : "var y = 1;\n"
816 : "while (x < 10) {\n"
817 : " y = y * 12;\n"
818 : " x = x + 1;\n"
819 : " if (x == 3) continue;\n"
820 : " if (x == 4) break;\n"
821 : "}\n"
822 : "return y;\n",
823 :
824 : "var i = 0;\n"
825 : "while (true) {\n"
826 : " if (i < 0) continue;\n"
827 : " if (i == 3) break;\n"
828 : " if (i == 4) break;\n"
829 : " if (i == 10) continue;\n"
830 : " if (i == 5) break;\n"
831 : " i = i + 1;\n"
832 : "}\n"
833 : "return i;\n",
834 :
835 : "var i = 0;\n"
836 : "while (true) {\n"
837 : " while (i < 3) {\n"
838 : " if (i == 2) break;\n"
839 : " i = i + 1;\n"
840 : " }\n"
841 : " i = i + 1;\n"
842 : " break;\n"
843 : "}\n"
844 : "return i;\n",
845 :
846 : "var x = 10;\n"
847 : "var y = 1;\n"
848 : "while (x) {\n"
849 : " y = y * 12;\n"
850 : " x = x - 1;\n"
851 : "}\n"
852 : "return y;\n",
853 :
854 : "var x = 0; var y = 1;\n"
855 : "do {\n"
856 : " y = y * 10;\n"
857 : " if (x == 5) break;\n"
858 : " if (x == 6) continue;\n"
859 : " x = x + 1;\n"
860 : "} while (x < 10);\n"
861 : "return y;\n",
862 :
863 : "var x = 10;\n"
864 : "var y = 1;\n"
865 : "do {\n"
866 : " y = y * 12;\n"
867 : " x = x - 1;\n"
868 : "} while (x);\n"
869 : "return y;\n",
870 :
871 : "var x = 0; var y = 1;\n"
872 : "do {\n"
873 : " y = y * 10;\n"
874 : " if (x == 5) break;\n"
875 : " x = x + 1;\n"
876 : " if (x == 6) continue;\n"
877 : "} while (false);\n"
878 : "return y;\n",
879 :
880 : "var x = 0; var y = 1;\n"
881 : "do {\n"
882 : " y = y * 10;\n"
883 : " if (x == 5) break;\n"
884 : " x = x + 1;\n"
885 : " if (x == 6) continue;\n"
886 : "} while (true);\n"
887 : "return y;\n",
888 :
889 : "var x = 0;\n"
890 : "for (;;) {\n"
891 : " if (x == 1) break;\n"
892 : " if (x == 2) continue;\n"
893 : " x = x + 1;\n"
894 : "}\n",
895 :
896 : "for (var x = 0;;) {\n"
897 : " if (x == 1) break;\n"
898 : " if (x == 2) continue;\n"
899 : " x = x + 1;\n"
900 : "}\n",
901 :
902 : "var x = 0;\n"
903 : "for (;; x = x + 1) {\n"
904 : " if (x == 1) break;\n"
905 : " if (x == 2) continue;\n"
906 : "}\n",
907 :
908 : "for (var x = 0;; x = x + 1) {\n"
909 : " if (x == 1) break;\n"
910 : " if (x == 2) continue;\n"
911 : "}\n",
912 :
913 : "var u = 0;\n"
914 : "for (var i = 0; i < 100; i = i + 1) {\n"
915 : " u = u + 1;\n"
916 : " continue;\n"
917 : "}\n",
918 :
919 : "var y = 1;\n"
920 : "for (var x = 10; x; --x) {\n"
921 : " y = y * 12;\n"
922 : "}\n"
923 : "return y;\n",
924 :
925 : "var x = 0;\n"
926 : "for (var i = 0; false; i++) {\n"
927 : " x = x + 1;\n"
928 : "};\n"
929 : "return x;\n",
930 :
931 : "var x = 0;\n"
932 : "for (var i = 0; true; ++i) {\n"
933 : " x = x + 1;\n"
934 : " if (x == 20) break;\n"
935 : "};\n"
936 : "return x;\n",
937 :
938 : "var a = 0;\n"
939 : "while (a) {\n"
940 : " { \n"
941 : " let z = 1;\n"
942 : " function f() { z = 2; }\n"
943 : " if (z) continue;\n"
944 : " z++;\n"
945 : " }\n"
946 : "}\n",
947 6 : };
948 :
949 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
950 : LoadGolden("BasicLoops.golden")));
951 6 : }
952 :
953 23724 : TEST(JumpsRequiringConstantWideOperands) {
954 : InitializedIgnitionHandleScope scope;
955 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
956 : const char* snippets[] = {
957 : REPEAT_256("var x = 0.1;\n")
958 : REPEAT_32("var x = 0.2;\n")
959 : REPEAT_16("var x = 0.3;\n")
960 : REPEAT_8("var x = 0.4;\n")
961 : "for (var i = 0; i < 3; i++) {\n"
962 : " if (i == 1) continue;\n"
963 : " if (i == 2) break;\n"
964 : "}\n"
965 : "return 3;\n",
966 6 : };
967 :
968 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
969 : LoadGolden("JumpsRequiringConstantWideOperands.golden")));
970 6 : }
971 :
972 23724 : TEST(UnaryOperators) {
973 : InitializedIgnitionHandleScope scope;
974 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
975 : const char* snippets[] = {
976 : "var x = 0;\n"
977 : "while (x != 10) {\n"
978 : " x = x + 10;\n"
979 : "}\n"
980 : "return x;\n",
981 :
982 : "var x = false;\n"
983 : "do {\n"
984 : " x = !x;\n"
985 : "} while(x == false);\n"
986 : "return x;\n",
987 :
988 : "var x = 101;\n"
989 : "return void(x * 3);\n",
990 :
991 : "var x = 1234;\n"
992 : "var y = void (x * x - 1);\n"
993 : "return y;\n",
994 :
995 : "var x = 13;\n"
996 : "return ~x;\n",
997 :
998 : "var x = 13;\n"
999 : "return +x;\n",
1000 :
1001 : "var x = 13;\n"
1002 : "return -x;\n",
1003 6 : };
1004 :
1005 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1006 : LoadGolden("UnaryOperators.golden")));
1007 6 : }
1008 :
1009 23724 : TEST(Typeof) {
1010 : InitializedIgnitionHandleScope scope;
1011 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1012 : printer.set_wrap(false);
1013 12 : printer.set_test_function_name("f");
1014 :
1015 : const char* snippets[] = {
1016 : "function f() {\n"
1017 : " var x = 13;\n"
1018 : " return typeof(x);\n"
1019 : "};",
1020 :
1021 : "var x = 13;\n"
1022 : "function f() {\n"
1023 : " return typeof(x);\n"
1024 : "};",
1025 6 : };
1026 :
1027 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1028 : LoadGolden("Typeof.golden")));
1029 6 : }
1030 :
1031 23724 : TEST(CompareTypeOf) {
1032 : InitializedIgnitionHandleScope scope;
1033 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1034 :
1035 : const char* snippets[] = {
1036 : "return typeof(1) === 'number';\n",
1037 :
1038 : "return 'string' === typeof('foo');\n",
1039 :
1040 : "return typeof(true) == 'boolean';\n",
1041 :
1042 : "return 'string' === typeof(undefined);\n",
1043 :
1044 : "return 'unknown' === typeof(undefined);\n",
1045 6 : };
1046 :
1047 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1048 : LoadGolden("CompareTypeOf.golden")));
1049 6 : }
1050 :
1051 23724 : TEST(CompareNil) {
1052 : InitializedIgnitionHandleScope scope;
1053 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1054 :
1055 : const char* snippets[] = {
1056 : "var a = 1;\n"
1057 : "return a === null;\n",
1058 :
1059 : "var a = undefined;\n"
1060 : "return undefined === a;\n",
1061 :
1062 : "var a = undefined;\n"
1063 : "return undefined !== a;\n",
1064 :
1065 : "var a = 2;\n"
1066 : "return a != null;\n",
1067 :
1068 : "var a = undefined;\n"
1069 : "return undefined == a;\n",
1070 :
1071 : "var a = undefined;\n"
1072 : "return undefined === a ? 1 : 2;\n",
1073 :
1074 : "var a = 0;\n"
1075 : "return null == a ? 1 : 2;\n",
1076 :
1077 : "var a = 0;\n"
1078 : "return undefined !== a ? 1 : 2;\n",
1079 :
1080 : "var a = 0;\n"
1081 : "return a === null ? 1 : 2;\n",
1082 :
1083 : "var a = 0;\n"
1084 : "if (a === null) {\n"
1085 : " return 1;\n"
1086 : "} else {\n"
1087 : " return 2;\n"
1088 : "}\n",
1089 :
1090 : "var a = 0;\n"
1091 : "if (a != undefined) {\n"
1092 : " return 1;\n"
1093 : "}\n",
1094 :
1095 : "var a = undefined;\n"
1096 : "var b = 0;\n"
1097 : "while (a !== undefined) {\n"
1098 : " b++;\n"
1099 : "}\n",
1100 6 : };
1101 :
1102 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1103 : LoadGolden("CompareNil.golden")));
1104 6 : }
1105 :
1106 23724 : TEST(Delete) {
1107 : InitializedIgnitionHandleScope scope;
1108 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1109 :
1110 : const char* snippets[] = {
1111 : "var a = {x:13, y:14}; return delete a.x;\n",
1112 :
1113 : "'use strict'; var a = {x:13, y:14}; return delete a.x;\n",
1114 :
1115 : "var a = {1:13, 2:14}; return delete a[2];\n",
1116 :
1117 : "var a = 10; return delete a;\n",
1118 :
1119 : "'use strict';\n"
1120 : "var a = {1:10};\n"
1121 : "(function f1() {return a;});\n"
1122 : "return delete a[1];\n",
1123 :
1124 : "return delete 'test';\n",
1125 6 : };
1126 :
1127 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1128 : LoadGolden("Delete.golden")));
1129 6 : }
1130 :
1131 23724 : TEST(GlobalDelete) {
1132 : InitializedIgnitionHandleScope scope;
1133 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1134 : printer.set_wrap(false);
1135 12 : printer.set_test_function_name("f");
1136 :
1137 : const char* snippets[] = {
1138 : "var a = {x:13, y:14};\n"
1139 : "function f() {\n"
1140 : " return delete a.x;\n"
1141 : "};\n"
1142 : "f();\n",
1143 :
1144 : "a = {1:13, 2:14};\n"
1145 : "function f() {\n"
1146 : " 'use strict';\n"
1147 : " return delete a[1];\n"
1148 : "};\n"
1149 : "f();\n",
1150 :
1151 : "var a = {x:13, y:14};\n"
1152 : "function f() {\n"
1153 : " return delete a;\n"
1154 : "};\n"
1155 : "f();\n",
1156 :
1157 : "b = 30;\n"
1158 : "function f() {\n"
1159 : " return delete b;\n"
1160 : "};\n"
1161 : "f();\n",
1162 6 : };
1163 :
1164 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1165 : LoadGolden("GlobalDelete.golden")));
1166 6 : }
1167 :
1168 23724 : TEST(FunctionLiterals) {
1169 : InitializedIgnitionHandleScope scope;
1170 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1171 :
1172 : const char* snippets[] = {
1173 : "return function(){ }\n",
1174 :
1175 : "return (function(){ })()\n",
1176 :
1177 : "return (function(x){ return x; })(1)\n",
1178 6 : };
1179 :
1180 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1181 : LoadGolden("FunctionLiterals.golden")));
1182 6 : }
1183 :
1184 23724 : TEST(RegExpLiterals) {
1185 : InitializedIgnitionHandleScope scope;
1186 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1187 :
1188 : const char* snippets[] = {
1189 : "return /ab+d/;\n",
1190 :
1191 : "return /(\\w+)\\s(\\w+)/i;\n",
1192 :
1193 : "return /ab+d/.exec('abdd');\n",
1194 6 : };
1195 :
1196 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1197 : LoadGolden("RegExpLiterals.golden")));
1198 6 : }
1199 :
1200 23724 : TEST(RegExpLiteralsWide) {
1201 : InitializedIgnitionHandleScope scope;
1202 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1203 :
1204 : const char* snippets[] = {
1205 : "var a;" //
1206 : REPEAT_256("\na = 1.23;") //
1207 : "\nreturn /ab+d/;\n",
1208 6 : };
1209 :
1210 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1211 : LoadGolden("RegExpLiteralsWide.golden")));
1212 6 : }
1213 :
1214 23724 : TEST(ArrayLiterals) {
1215 : InitializedIgnitionHandleScope scope;
1216 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1217 :
1218 : const char* snippets[] = {
1219 : "return [ 1, 2 ];\n",
1220 :
1221 : "var a = 1; return [ a, a + 1 ];\n",
1222 :
1223 : "return [ [ 1, 2 ], [ 3 ] ];\n",
1224 :
1225 : "var a = 1; return [ [ a, 2 ], [ a + 2 ] ];\n",
1226 6 : };
1227 :
1228 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1229 : LoadGolden("ArrayLiterals.golden")));
1230 6 : }
1231 :
1232 23724 : TEST(ArrayLiteralsWide) {
1233 : InitializedIgnitionHandleScope scope;
1234 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1235 :
1236 : const char* snippets[] = {
1237 : "var a;" //
1238 : REPEAT_256("\na = 1.23;") //
1239 : "\nreturn [ 1 , 2 ];\n",
1240 6 : };
1241 :
1242 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1243 : LoadGolden("ArrayLiteralsWide.golden")));
1244 6 : }
1245 :
1246 23724 : TEST(ObjectLiterals) {
1247 : InitializedIgnitionHandleScope scope;
1248 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1249 :
1250 : const char* snippets[] = {
1251 : "return { };\n",
1252 :
1253 : "return { name: 'string', val: 9.2 };\n",
1254 :
1255 : "var a = 1; return { name: 'string', val: a };\n",
1256 :
1257 : "var a = 1; return { val: a, val: a + 1 };\n",
1258 :
1259 : "return { func: function() { } };\n",
1260 :
1261 : "return { func(a) { return a; } };\n",
1262 :
1263 : "return { get a() { return 2; } };\n",
1264 :
1265 : "return { get a() { return this.x; }, set a(val) { this.x = val } };\n",
1266 :
1267 : "return { set b(val) { this.y = val } };\n",
1268 :
1269 : "var a = 1; return { 1: a };\n",
1270 :
1271 : "return { __proto__: null };\n",
1272 :
1273 : "var a = 'test'; return { [a]: 1 };\n",
1274 :
1275 : "var a = 'test'; return { val: a, [a]: 1 };\n",
1276 :
1277 : "var a = 'test'; return { [a]: 1, __proto__: {} };\n",
1278 :
1279 : "var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };\n",
1280 6 : };
1281 :
1282 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1283 : LoadGolden("ObjectLiterals.golden")));
1284 6 : }
1285 :
1286 23724 : TEST(ObjectLiteralsWide) {
1287 : InitializedIgnitionHandleScope scope;
1288 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1289 : const char* snippets[] = {
1290 : "var a;" //
1291 : REPEAT_256("\na = 1.23;") //
1292 : "\nreturn { name: 'string', val: 9.2 };\n",
1293 6 : };
1294 :
1295 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1296 : LoadGolden("ObjectLiteralsWide.golden")));
1297 6 : }
1298 :
1299 23724 : TEST(TopLevelObjectLiterals) {
1300 : InitializedIgnitionHandleScope scope;
1301 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1302 : printer.set_wrap(false);
1303 12 : printer.set_test_function_name("f");
1304 : printer.set_top_level(true);
1305 :
1306 : const char* snippets[] = {
1307 : "var a = { func: function() { } };\n",
1308 6 : };
1309 :
1310 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1311 : LoadGolden("TopLevelObjectLiterals.golden")));
1312 6 : }
1313 :
1314 23724 : TEST(TryCatch) {
1315 : InitializedIgnitionHandleScope scope;
1316 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1317 :
1318 : const char* snippets[] = {
1319 : "try { return 1; } catch(e) { return 2; }\n",
1320 :
1321 : "var a;\n"
1322 : "try { a = 1 } catch(e1) {};\n"
1323 : "try { a = 2 } catch(e2) { a = 3 }\n",
1324 6 : };
1325 :
1326 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1327 : LoadGolden("TryCatch.golden")));
1328 6 : }
1329 :
1330 23724 : TEST(TryFinally) {
1331 : InitializedIgnitionHandleScope scope;
1332 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1333 : const char* snippets[] = {
1334 : "var a = 1;\n"
1335 : "try { a = 2; } finally { a = 3; }\n",
1336 :
1337 : "var a = 1;\n"
1338 : "try { a = 2; } catch(e) { a = 20 } finally { a = 3; }\n",
1339 :
1340 : "var a; try {\n"
1341 : " try { a = 1 } catch(e) { a = 2 }\n"
1342 : "} catch(e) { a = 20 } finally { a = 3; }\n",
1343 6 : };
1344 :
1345 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1346 : LoadGolden("TryFinally.golden")));
1347 6 : }
1348 :
1349 23724 : TEST(Throw) {
1350 : InitializedIgnitionHandleScope scope;
1351 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1352 : const char* snippets[] = {
1353 : "throw 1;\n",
1354 :
1355 : "throw 'Error';\n",
1356 :
1357 : "var a = 1; if (a) { throw 'Error'; };\n",
1358 6 : };
1359 :
1360 24 : CHECK(
1361 : CompareTexts(BuildActual(printer, snippets), LoadGolden("Throw.golden")));
1362 6 : }
1363 :
1364 23724 : TEST(CallNew) {
1365 : InitializedIgnitionHandleScope scope;
1366 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1367 : printer.set_wrap(false);
1368 12 : printer.set_test_function_name("f");
1369 :
1370 : const char* snippets[] = {
1371 : "function bar() { this.value = 0; }\n"
1372 : "function f() { return new bar(); }\n"
1373 : "f();\n",
1374 :
1375 : "function bar(x) { this.value = 18; this.x = x;}\n"
1376 : "function f() { return new bar(3); }\n"
1377 : "f();\n",
1378 :
1379 : "function bar(w, x, y, z) {\n"
1380 : " this.value = 18;\n"
1381 : " this.x = x;\n"
1382 : " this.y = y;\n"
1383 : " this.z = z;\n"
1384 : "}\n"
1385 : "function f() { return new bar(3, 4, 5); }\n"
1386 : "f();\n",
1387 6 : };
1388 :
1389 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1390 : LoadGolden("CallNew.golden")));
1391 6 : }
1392 :
1393 23724 : TEST(ContextVariables) {
1394 : // The wide check below relies on MIN_CONTEXT_SLOTS + 3 + 249 == 256, if this
1395 : // ever changes, the REPEAT_XXX should be changed to output the correct number
1396 : // of unique variables to trigger the wide slot load / store.
1397 : STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS + 3 + 249 == 256);
1398 :
1399 : InitializedIgnitionHandleScope scope;
1400 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1401 : const char* snippets[] = {
1402 : "var a; return function() { a = 1; };\n",
1403 :
1404 : "var a = 1; return function() { a = 2; };\n",
1405 :
1406 : "var a = 1; var b = 2; return function() { a = 2; b = 3 };\n",
1407 :
1408 : "var a; (function() { a = 2; })(); return a;\n",
1409 :
1410 : "'use strict';\n"
1411 : "let a = 1;\n"
1412 : "{ let b = 2; return function() { a + b; }; }\n",
1413 :
1414 : "'use strict';\n"
1415 : REPEAT_250_UNIQUE_VARS()
1416 : "eval();\n"
1417 : "var b = 100;\n"
1418 : "return b\n",
1419 6 : };
1420 :
1421 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1422 : LoadGolden("ContextVariables.golden")));
1423 6 : }
1424 :
1425 23724 : TEST(ContextParameters) {
1426 : InitializedIgnitionHandleScope scope;
1427 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1428 : printer.set_wrap(false);
1429 12 : printer.set_test_function_name("f");
1430 :
1431 : const char* snippets[] = {
1432 : "function f(arg1) { return function() { arg1 = 2; }; }",
1433 :
1434 : "function f(arg1) { var a = function() { arg1 = 2; }; return arg1; }",
1435 :
1436 : "function f(a1, a2, a3, a4) { return function() { a1 = a3; }; }",
1437 :
1438 : "function f() { var self = this; return function() { self = 2; }; }",
1439 6 : };
1440 :
1441 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1442 : LoadGolden("ContextParameters.golden")));
1443 6 : }
1444 :
1445 23724 : TEST(OuterContextVariables) {
1446 : InitializedIgnitionHandleScope scope;
1447 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1448 : printer.set_wrap(false);
1449 12 : printer.set_test_function_name("f");
1450 :
1451 : const char* snippets[] = {
1452 : "function Outer() {\n"
1453 : " var outerVar = 1;\n"
1454 : " function Inner(innerArg) {\n"
1455 : " this.innerFunc = function() { return outerVar * innerArg; }\n"
1456 : " }\n"
1457 : " this.getInnerFunc = function() { return new Inner(1).innerFunc; }\n"
1458 : "}\n"
1459 : "var f = new Outer().getInnerFunc();",
1460 :
1461 : "function Outer() {\n"
1462 : " var outerVar = 1;\n"
1463 : " function Inner(innerArg) {\n"
1464 : " this.innerFunc = function() { outerVar = innerArg; }\n"
1465 : " }\n"
1466 : " this.getInnerFunc = function() { return new Inner(1).innerFunc; }\n"
1467 : "}\n"
1468 : "var f = new Outer().getInnerFunc();",
1469 6 : };
1470 :
1471 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1472 : LoadGolden("OuterContextVariables.golden")));
1473 6 : }
1474 :
1475 23724 : TEST(CountOperators) {
1476 : InitializedIgnitionHandleScope scope;
1477 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1478 : const char* snippets[] = {
1479 : "var a = 1; return ++a;\n",
1480 :
1481 : "var a = 1; return a++;\n",
1482 :
1483 : "var a = 1; return --a;\n",
1484 :
1485 : "var a = 1; return a--;\n",
1486 :
1487 : "var a = { val: 1 }; return a.val++;\n",
1488 :
1489 : "var a = { val: 1 }; return --a.val;\n",
1490 :
1491 : "var name = 'var'; var a = { val: 1 }; return a[name]--;\n",
1492 :
1493 : "var name = 'var'; var a = { val: 1 }; return ++a[name];\n",
1494 :
1495 : "var a = 1; var b = function() { return a }; return ++a;\n",
1496 :
1497 : "var a = 1; var b = function() { return a }; return a--;\n",
1498 :
1499 : "var idx = 1; var a = [1, 2]; return a[idx++] = 2;\n",
1500 6 : };
1501 :
1502 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1503 : LoadGolden("CountOperators.golden")));
1504 6 : }
1505 :
1506 23724 : TEST(GlobalCountOperators) {
1507 : InitializedIgnitionHandleScope scope;
1508 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1509 : printer.set_wrap(false);
1510 12 : printer.set_test_function_name("f");
1511 :
1512 : const char* snippets[] = {
1513 : "var global = 1;\n"
1514 : "function f() { return ++global; }\n"
1515 : "f();\n",
1516 :
1517 : "var global = 1;\n"
1518 : "function f() { return global--; }\n"
1519 : "f();\n",
1520 :
1521 : "unallocated = 1;\n"
1522 : "function f() { 'use strict'; return --unallocated; }\n"
1523 : "f();\n",
1524 :
1525 : "unallocated = 1;\n"
1526 : "function f() { return unallocated++; }\n"
1527 : "f();\n",
1528 6 : };
1529 :
1530 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1531 : LoadGolden("GlobalCountOperators.golden")));
1532 6 : }
1533 :
1534 23724 : TEST(CompoundExpressions) {
1535 : InitializedIgnitionHandleScope scope;
1536 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1537 : const char* snippets[] = {
1538 : "var a = 1; a += 2;\n",
1539 :
1540 : "var a = 1; a /= 2;\n",
1541 :
1542 : "var a = { val: 2 }; a.name *= 2;\n",
1543 :
1544 : "var a = { 1: 2 }; a[1] ^= 2;\n",
1545 :
1546 : "var a = 1; (function f() { return a; }); a |= 24;\n",
1547 6 : };
1548 :
1549 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1550 : LoadGolden("CompoundExpressions.golden")));
1551 6 : }
1552 :
1553 23724 : TEST(GlobalCompoundExpressions) {
1554 : InitializedIgnitionHandleScope scope;
1555 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1556 : printer.set_wrap(false);
1557 12 : printer.set_test_function_name("f");
1558 :
1559 : const char* snippets[] = {
1560 : "var global = 1;\n"
1561 : "function f() { return global &= 1; }\n"
1562 : "f();\n",
1563 :
1564 : "unallocated = 1;\n"
1565 : "function f() { return unallocated += 1; }\n"
1566 : "f();\n",
1567 6 : };
1568 :
1569 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1570 : LoadGolden("GlobalCompoundExpressions.golden")));
1571 6 : }
1572 :
1573 23724 : TEST(CreateArguments) {
1574 : InitializedIgnitionHandleScope scope;
1575 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1576 : printer.set_wrap(false);
1577 12 : printer.set_test_function_name("f");
1578 :
1579 : const char* snippets[] = {
1580 : "function f() { return arguments; }",
1581 :
1582 : "function f() { return arguments[0]; }",
1583 :
1584 : "function f() { 'use strict'; return arguments; }",
1585 :
1586 : "function f(a) { return arguments[0]; }",
1587 :
1588 : "function f(a, b, c) { return arguments; }",
1589 :
1590 : "function f(a, b, c) { 'use strict'; return arguments; }",
1591 6 : };
1592 :
1593 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1594 : LoadGolden("CreateArguments.golden")));
1595 6 : }
1596 :
1597 23724 : TEST(CreateRestParameter) {
1598 : InitializedIgnitionHandleScope scope;
1599 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1600 : printer.set_wrap(false);
1601 12 : printer.set_test_function_name("f");
1602 :
1603 : const char* snippets[] = {
1604 : "function f(...restArgs) { return restArgs; }",
1605 :
1606 : "function f(a, ...restArgs) { return restArgs; }",
1607 :
1608 : "function f(a, ...restArgs) { return restArgs[0]; }",
1609 :
1610 : "function f(a, ...restArgs) { return restArgs[0] + arguments[0]; }",
1611 6 : };
1612 :
1613 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1614 : LoadGolden("CreateRestParameter.golden")));
1615 6 : }
1616 :
1617 23724 : TEST(ForIn) {
1618 : InitializedIgnitionHandleScope scope;
1619 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1620 : const char* snippets[] = {
1621 : "for (var p in null) {}\n",
1622 :
1623 : "for (var p in undefined) {}\n",
1624 :
1625 : "for (var p in undefined) {}\n",
1626 :
1627 : "var x = 'potatoes';\n"
1628 : "for (var p in x) { return p; }\n",
1629 :
1630 : "var x = 0;\n"
1631 : "for (var p in [1,2,3]) { x += p; }\n",
1632 :
1633 : "var x = { 'a': 1, 'b': 2 };\n"
1634 : "for (x['a'] in [10, 20, 30]) {\n"
1635 : " if (x['a'] == 10) continue;\n"
1636 : " if (x['a'] == 20) break;\n"
1637 : "}\n",
1638 :
1639 : "var x = [ 10, 11, 12 ] ;\n"
1640 : "for (x[0] in [1,2,3]) { return x[3]; }\n",
1641 6 : };
1642 :
1643 24 : CHECK(
1644 : CompareTexts(BuildActual(printer, snippets), LoadGolden("ForIn.golden")));
1645 6 : }
1646 :
1647 23724 : TEST(ForOf) {
1648 : InitializedIgnitionHandleScope scope;
1649 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1650 : const char* snippets[] = {
1651 : "for (var p of [0, 1, 2]) {}\n",
1652 :
1653 : "var x = 'potatoes';\n"
1654 : "for (var p of x) { return p; }\n",
1655 :
1656 : "for (var x of [10, 20, 30]) {\n"
1657 : " if (x == 10) continue;\n"
1658 : " if (x == 20) break;\n"
1659 : "}\n",
1660 :
1661 : "var x = { 'a': 1, 'b': 2 };\n"
1662 : "for (x['a'] of [1,2,3]) { return x['a']; }\n",
1663 6 : };
1664 :
1665 24 : CHECK(
1666 : CompareTexts(BuildActual(printer, snippets), LoadGolden("ForOf.golden")));
1667 6 : }
1668 :
1669 23724 : TEST(Conditional) {
1670 : InitializedIgnitionHandleScope scope;
1671 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1672 : const char* snippets[] = {
1673 : "return 1 ? 2 : 3;\n",
1674 :
1675 : "return 1 ? 2 ? 3 : 4 : 5;\n",
1676 :
1677 : "return 0 < 1 ? 2 : 3;\n",
1678 :
1679 : "var x = 0;\n"
1680 : "return x ? 2 : 3;\n",
1681 6 : };
1682 :
1683 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1684 : LoadGolden("Conditional.golden")));
1685 6 : }
1686 :
1687 23724 : TEST(Switch) {
1688 : InitializedIgnitionHandleScope scope;
1689 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1690 : const char* snippets[] = {
1691 : "var a = 1;\n"
1692 : "switch(a) {\n"
1693 : " case 1: return 2;\n"
1694 : " case 2: return 3;\n"
1695 : "}\n",
1696 :
1697 : "var a = 1;\n"
1698 : "switch(a) {\n"
1699 : " case 1: a = 2; break;\n"
1700 : " case 2: a = 3; break;\n"
1701 : "}\n",
1702 :
1703 : "var a = 1;\n"
1704 : "switch(a) {\n"
1705 : " case 1: a = 2; // fall-through\n"
1706 : " case 2: a = 3; break;\n"
1707 : "}\n",
1708 :
1709 : "var a = 1;\n"
1710 : "switch(a) {\n"
1711 : " case 2: break;\n"
1712 : " case 3: break;\n"
1713 : " default: a = 1; break;\n"
1714 : "}\n",
1715 :
1716 : "var a = 1;\n"
1717 : "switch(typeof(a)) {\n"
1718 : " case 2: a = 1; break;\n"
1719 : " case 3: a = 2; break;\n"
1720 : " default: a = 3; break;\n"
1721 : "}\n",
1722 :
1723 : "var a = 1;\n"
1724 : "switch(a) {\n"
1725 : " case typeof(a): a = 1; break;\n"
1726 : " default: a = 2; break;\n"
1727 : "}\n",
1728 :
1729 : "var a = 1;\n"
1730 : "switch(a) {\n"
1731 : " case 1:\n"
1732 : REPEAT_64(" a = 2;\n")
1733 : " break;\n"
1734 : " case 2:\n"
1735 : " a = 3;\n"
1736 : " break;\n"
1737 : "}\n",
1738 :
1739 : "var a = 1;\n"
1740 : "switch(a) {\n"
1741 : " case 1: \n"
1742 : " switch(a + 1) {\n"
1743 : " case 2 : a = 1; break;\n"
1744 : " default : a = 2; break;\n"
1745 : " } // fall-through\n"
1746 : " case 2: a = 3;\n"
1747 : "}\n",
1748 6 : };
1749 :
1750 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1751 : LoadGolden("Switch.golden")));
1752 6 : }
1753 :
1754 23724 : TEST(BasicBlockToBoolean) {
1755 : InitializedIgnitionHandleScope scope;
1756 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1757 : const char* snippets[] = {
1758 : "var a = 1; if (a || a < 0) { return 1; }\n",
1759 :
1760 : "var a = 1; if (a && a < 0) { return 1; }\n",
1761 :
1762 : "var a = 1; a = (a || a < 0) ? 2 : 3;\n",
1763 6 : };
1764 :
1765 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1766 : LoadGolden("BasicBlockToBoolean.golden")));
1767 6 : }
1768 :
1769 23724 : TEST(DeadCodeRemoval) {
1770 : InitializedIgnitionHandleScope scope;
1771 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1772 : const char* snippets[] = {
1773 : "return; var a = 1; a();\n",
1774 :
1775 : "if (false) { return; }; var a = 1;\n",
1776 :
1777 : "if (true) { return 1; } else { return 2; };\n",
1778 :
1779 : "var a = 1; if (a) { return 1; }; return 2;\n",
1780 6 : };
1781 :
1782 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1783 : LoadGolden("DeadCodeRemoval.golden")));
1784 6 : }
1785 :
1786 23724 : TEST(ThisFunction) {
1787 : InitializedIgnitionHandleScope scope;
1788 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1789 : printer.set_wrap(false);
1790 12 : printer.set_test_function_name("f");
1791 :
1792 : const char* snippets[] = {
1793 : "var f;\n"
1794 : "f = function f() {};",
1795 :
1796 : "var f;\n"
1797 : "f = function f() { return f; };",
1798 6 : };
1799 :
1800 24 : CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
1801 : LoadGolden("ThisFunction.golden")));
1802 6 : }
1803 :
1804 23724 : TEST(NewTarget) {
1805 : InitializedIgnitionHandleScope scope;
1806 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1807 :
1808 : const char* snippets[] = {
1809 : "return new.target;\n",
1810 :
1811 : "new.target;\n",
1812 6 : };
1813 :
1814 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1815 : LoadGolden("NewTarget.golden")));
1816 6 : }
1817 :
1818 23724 : TEST(RemoveRedundantLdar) {
1819 : InitializedIgnitionHandleScope scope;
1820 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1821 : const char* snippets[] = {
1822 : "var ld_a = 1;\n" // This test is to check Ldar does not
1823 : "while(true) {\n" // get removed if the preceding Star is
1824 : " ld_a = ld_a + ld_a;\n" // in a different basicblock.
1825 : " if (ld_a > 10) break;\n"
1826 : "}\n"
1827 : "return ld_a;\n",
1828 :
1829 : "var ld_a = 1;\n"
1830 : "do {\n"
1831 : " ld_a = ld_a + ld_a;\n"
1832 : " if (ld_a > 10) continue;\n"
1833 : "} while(false);\n"
1834 : "return ld_a;\n",
1835 :
1836 : "var ld_a = 1;\n"
1837 : " ld_a = ld_a + ld_a;\n"
1838 : " return ld_a;\n",
1839 6 : };
1840 :
1841 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1842 : LoadGolden("RemoveRedundantLdar.golden")));
1843 6 : }
1844 :
1845 23724 : TEST(GenerateTestUndetectable) {
1846 : InitializedIgnitionHandleScope scope;
1847 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1848 : const char* snippets[] = {
1849 : "var obj_a = {val:1};\n"
1850 : "var b = 10;\n"
1851 : "if (obj_a == null) { b = 20;}\n"
1852 : "return b;\n",
1853 :
1854 : "var obj_a = {val:1};\n"
1855 : "var b = 10;\n"
1856 : "if (obj_a == undefined) { b = 20;}\n"
1857 : "return b;\n",
1858 :
1859 : "var obj_a = {val:1};\n"
1860 : "var b = 10;\n"
1861 : "if (obj_a != null) { b = 20;}\n"
1862 : "return b;\n",
1863 :
1864 : "var obj_a = {val:1};\n"
1865 : "var b = 10;\n"
1866 : "if (obj_a != undefined) { b = 20;}\n"
1867 : "return b;\n",
1868 :
1869 : "var obj_a = {val:1};\n"
1870 : "var b = 10;\n"
1871 : "if (obj_a === null) { b = 20;}\n"
1872 : "return b;\n",
1873 :
1874 : "var obj_a = {val:1};\n"
1875 : "var b = 10;\n"
1876 : "if (obj_a === undefined) { b = 20;}\n"
1877 : "return b;\n",
1878 :
1879 : "var obj_a = {val:1};\n"
1880 : "var b = 10;\n"
1881 : "if (obj_a !== null) { b = 20;}\n"
1882 : "return b;\n",
1883 :
1884 : "var obj_a = {val:1};\n"
1885 : "var b = 10;\n"
1886 : "if (obj_a !== undefined) { b = 20;}\n"
1887 6 : "return b;\n"};
1888 :
1889 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1890 : LoadGolden("GenerateTestUndetectable.golden")));
1891 6 : }
1892 :
1893 23724 : TEST(AssignmentsInBinaryExpression) {
1894 : InitializedIgnitionHandleScope scope;
1895 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1896 : const char* snippets[] = {
1897 : "var x = 0, y = 1;\n"
1898 : "return (x = 2, y = 3, x = 4, y = 5);\n",
1899 :
1900 : "var x = 55;\n"
1901 : "var y = (x = 100);\n"
1902 : "return y;\n",
1903 :
1904 : "var x = 55;\n"
1905 : "x = x + (x = 100) + (x = 101);\n"
1906 : "return x;\n",
1907 :
1908 : "var x = 55;\n"
1909 : "x = (x = 56) - x + (x = 57);\n"
1910 : "x++;\n"
1911 : "return x;\n",
1912 :
1913 : "var x = 55;\n"
1914 : "var y = x + (x = 1) + (x = 2) + (x = 3);\n"
1915 : "return y;\n",
1916 :
1917 : "var x = 55;\n"
1918 : "var x = x + (x = 1) + (x = 2) + (x = 3);\n"
1919 : "return x;\n",
1920 :
1921 : "var x = 10, y = 20;\n"
1922 : "return x + (x = 1) + (x + 1) * (y = 2) + (y = 3) + (x = 4) + (y = 5) + "
1923 : "y;\n",
1924 :
1925 : "var x = 17;\n"
1926 : "return 1 + x + (x++) + (++x);\n",
1927 6 : };
1928 :
1929 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1930 : LoadGolden("AssignmentsInBinaryExpression.golden")));
1931 6 : }
1932 :
1933 23724 : TEST(Eval) {
1934 : InitializedIgnitionHandleScope scope;
1935 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1936 : const char* snippets[] = {
1937 : "return eval('1;');\n",
1938 6 : };
1939 :
1940 24 : CHECK(
1941 : CompareTexts(BuildActual(printer, snippets), LoadGolden("Eval.golden")));
1942 6 : }
1943 :
1944 23724 : TEST(LookupSlot) {
1945 : InitializedIgnitionHandleScope scope;
1946 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1947 12 : printer.set_test_function_name("f");
1948 :
1949 : // clang-format off
1950 : const char* snippets[] = {
1951 : "eval('var x = 10;'); return x;\n",
1952 :
1953 : "eval('var x = 10;'); return typeof x;\n",
1954 :
1955 : "x = 20; return eval('');\n",
1956 :
1957 : "var x = 20;\n"
1958 : "f = function(){\n"
1959 : " eval('var x = 10');\n"
1960 : " return x;\n"
1961 : "}\n"
1962 : "f();\n",
1963 :
1964 : "x = 20;\n"
1965 : "f = function(){\n"
1966 : " eval('var x = 10');\n"
1967 : " return x;\n"
1968 : "}\n"
1969 : "f();\n"
1970 6 : };
1971 : // clang-format on
1972 :
1973 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1974 : LoadGolden("LookupSlot.golden")));
1975 6 : }
1976 :
1977 23724 : TEST(CallLookupSlot) {
1978 : InitializedIgnitionHandleScope scope;
1979 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1980 : const char* snippets[] = {
1981 : "g = function(){}; eval(''); return g();\n",
1982 6 : };
1983 :
1984 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
1985 : LoadGolden("CallLookupSlot.golden")));
1986 6 : }
1987 :
1988 : // TODO(mythria): tests for variable/function declaration in lookup slots.
1989 :
1990 23724 : TEST(LookupSlotInEval) {
1991 : InitializedIgnitionHandleScope scope;
1992 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
1993 : printer.set_wrap(false);
1994 12 : printer.set_test_function_name("f");
1995 :
1996 : const char* snippets[] = {
1997 : "return x;",
1998 :
1999 : "x = 10;",
2000 :
2001 : "'use strict'; x = 10;",
2002 :
2003 : "return typeof x;",
2004 6 : };
2005 :
2006 : std::string actual = BuildActual(printer, snippets,
2007 : "var f;\n"
2008 : "var x = 1;\n"
2009 : "function f1() {\n"
2010 : " eval(\"function t() { ",
2011 :
2012 : " }; f = t; f();\");\n"
2013 : "}\n"
2014 6 : "f1();");
2015 :
2016 18 : CHECK(CompareTexts(actual, LoadGolden("LookupSlotInEval.golden")));
2017 6 : }
2018 :
2019 23724 : TEST(LookupSlotWideInEval) {
2020 : InitializedIgnitionHandleScope scope;
2021 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2022 : printer.set_wrap(false);
2023 12 : printer.set_test_function_name("f");
2024 :
2025 : const char* snippets[] = {
2026 : REPEAT_256(" \"var y = 2.3;\" +\n") //
2027 : " \"return x;\" +\n",
2028 :
2029 : REPEAT_256(" \"var y = 2.3;\" +\n") //
2030 : " \"return typeof x;\" +\n",
2031 :
2032 : REPEAT_256(" \"var y = 2.3;\" +\n") //
2033 : " \"x = 10;\" +\n",
2034 :
2035 : " \"'use strict';\" +\n" //
2036 : REPEAT_256(" \"var y = 2.3;\" +\n") //
2037 : " \"x = 10;\" +\n",
2038 6 : };
2039 :
2040 : std::string actual = BuildActual(printer, snippets,
2041 : "var f;\n"
2042 : "var x = 1;\n"
2043 : "function f1() {\n"
2044 : " eval(\"function t() {\" +\n",
2045 :
2046 : " \"};\" +\n"
2047 : " \"f = t; f();\"\n);\n"
2048 : "}\n"
2049 6 : "f1();");
2050 :
2051 18 : CHECK(CompareTexts(actual, LoadGolden("LookupSlotWideInEval.golden")));
2052 6 : }
2053 :
2054 23724 : TEST(DeleteLookupSlotInEval) {
2055 : InitializedIgnitionHandleScope scope;
2056 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2057 : printer.set_wrap(false);
2058 12 : printer.set_test_function_name("f");
2059 :
2060 : const char* snippets[] = {
2061 : "delete x;",
2062 :
2063 : "return delete y;",
2064 :
2065 : "return delete z;",
2066 6 : };
2067 :
2068 : std::string actual = BuildActual(printer, snippets,
2069 : "var f;\n"
2070 : "var x = 1;\n"
2071 : "z = 10;\n"
2072 : "function f1() {\n"
2073 : " var y;\n"
2074 : " eval(\"function t() { ",
2075 :
2076 : " }; f = t; f();\");\n"
2077 : "}\n"
2078 6 : "f1();");
2079 :
2080 18 : CHECK(CompareTexts(actual, LoadGolden("DeleteLookupSlotInEval.golden")));
2081 6 : }
2082 :
2083 23724 : TEST(WideRegisters) {
2084 : // Prepare prologue that creates frame for lots of registers.
2085 6 : std::ostringstream os;
2086 948 : for (size_t i = 0; i < 157; ++i) {
2087 1884 : os << "var x" << i << ";\n";
2088 : }
2089 : std::string prologue(os.str());
2090 :
2091 : InitializedIgnitionHandleScope scope;
2092 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2093 : const char* snippets[] = {
2094 : "x0 = x127;\n"
2095 : "return x0;\n",
2096 :
2097 : "x127 = x126;\n"
2098 : "return x127;\n",
2099 :
2100 : "if (x2 > 3) { return x129; }\n"
2101 : "return x128;\n",
2102 :
2103 : "var x0 = 0;\n"
2104 : "if (x129 == 3) { var x129 = x0; }\n"
2105 : "if (x2 > 3) { return x0; }\n"
2106 : "return x129;\n",
2107 :
2108 : "var x0 = 0;\n"
2109 : "var x1 = 0;\n"
2110 : "for (x128 = 0; x128 < 64; x128++) {"
2111 : " x1 += x128;"
2112 : "}"
2113 : "return x128;\n",
2114 :
2115 : "var x0 = 1234;\n"
2116 : "var x1 = 0;\n"
2117 : "for (x128 in x0) {"
2118 : " x1 += x128;"
2119 : "}"
2120 : "return x1;\n",
2121 :
2122 : "x0 = %Add(x64, x63);\n"
2123 : "x1 = %Add(x27, x143);\n"
2124 : "%TheHole();\n"
2125 : "return x1;\n",
2126 6 : };
2127 :
2128 30 : CHECK(CompareTexts(BuildActual(printer, snippets, prologue.c_str()),
2129 6 : LoadGolden("WideRegisters.golden")));
2130 6 : }
2131 :
2132 23724 : TEST(ConstVariable) {
2133 : InitializedIgnitionHandleScope scope;
2134 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2135 : const char* snippets[] = {
2136 : "const x = 10;\n",
2137 :
2138 : "const x = 10; return x;\n",
2139 :
2140 : "const x = ( x = 20);\n",
2141 :
2142 : "const x = 10; x = 20;\n",
2143 6 : };
2144 :
2145 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2146 : LoadGolden("ConstVariable.golden")));
2147 6 : }
2148 :
2149 23724 : TEST(LetVariable) {
2150 : InitializedIgnitionHandleScope scope;
2151 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2152 : const char* snippets[] = {
2153 : "let x = 10;\n",
2154 :
2155 : "let x = 10; return x;\n",
2156 :
2157 : "let x = (x = 20);\n",
2158 :
2159 : "let x = 10; x = 20;\n",
2160 6 : };
2161 :
2162 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2163 : LoadGolden("LetVariable.golden")));
2164 6 : }
2165 :
2166 23724 : TEST(ConstVariableContextSlot) {
2167 : // TODO(mythria): Add tests for initialization of this via super calls.
2168 : // TODO(mythria): Add tests that walk the context chain.
2169 : InitializedIgnitionHandleScope scope;
2170 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2171 : const char* snippets[] = {
2172 : "const x = 10; function f1() {return x;}\n",
2173 :
2174 : "const x = 10; function f1() {return x;} return x;\n",
2175 :
2176 : "const x = (x = 20); function f1() {return x;}\n",
2177 :
2178 : "const x = 10; x = 20; function f1() {return x;}\n",
2179 6 : };
2180 :
2181 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2182 : LoadGolden("ConstVariableContextSlot.golden")));
2183 6 : }
2184 :
2185 23724 : TEST(LetVariableContextSlot) {
2186 : InitializedIgnitionHandleScope scope;
2187 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2188 : const char* snippets[] = {
2189 : "let x = 10; function f1() {return x;}\n",
2190 :
2191 : "let x = 10; function f1() {return x;} return x;\n",
2192 :
2193 : "let x = (x = 20); function f1() {return x;}\n",
2194 :
2195 : "let x = 10; x = 20; function f1() {return x;}\n",
2196 6 : };
2197 :
2198 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2199 : LoadGolden("LetVariableContextSlot.golden")));
2200 6 : }
2201 :
2202 23724 : TEST(DoExpression) {
2203 6 : bool old_flag = FLAG_harmony_do_expressions;
2204 6 : FLAG_harmony_do_expressions = true;
2205 :
2206 : InitializedIgnitionHandleScope scope;
2207 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2208 : const char* snippets[] = {
2209 : "var a = do { }; return a;\n",
2210 :
2211 : "var a = do { var x = 100; }; return a;\n",
2212 :
2213 : "while(true) { var a = 10; a = do { ++a; break; }; a = 20; }\n",
2214 6 : };
2215 :
2216 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2217 : LoadGolden("DoExpression.golden")));
2218 :
2219 6 : FLAG_harmony_do_expressions = old_flag;
2220 6 : }
2221 :
2222 23724 : TEST(WithStatement) {
2223 : InitializedIgnitionHandleScope scope;
2224 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2225 : const char* snippets[] = {
2226 : "with ({x:42}) { return x; }\n",
2227 6 : };
2228 :
2229 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2230 : LoadGolden("WithStatement.golden")));
2231 6 : }
2232 :
2233 23724 : TEST(DoDebugger) {
2234 : InitializedIgnitionHandleScope scope;
2235 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2236 : const char* snippets[] = {
2237 : "debugger;\n",
2238 6 : };
2239 :
2240 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2241 : LoadGolden("DoDebugger.golden")));
2242 6 : }
2243 :
2244 23724 : TEST(ClassDeclarations) {
2245 : InitializedIgnitionHandleScope scope;
2246 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2247 : const char* snippets[] = {
2248 : "class Person {\n"
2249 : " constructor(name) { this.name = name; }\n"
2250 : " speak() { console.log(this.name + ' is speaking.'); }\n"
2251 : "}\n",
2252 :
2253 : "class person {\n"
2254 : " constructor(name) { this.name = name; }\n"
2255 : " speak() { console.log(this.name + ' is speaking.'); }\n"
2256 : "}\n",
2257 :
2258 : "var n0 = 'a';\n"
2259 : "var n1 = 'b';\n"
2260 : "class N {\n"
2261 : " [n0]() { return n0; }\n"
2262 : " static [n1]() { return n1; }\n"
2263 : "}\n",
2264 :
2265 : "var count = 0;\n"
2266 : "class C { constructor() { count++; }}\n"
2267 : "return new C();\n",
2268 :
2269 : "(class {})\n"
2270 : "class E { static name () {}}\n",
2271 6 : };
2272 :
2273 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2274 : LoadGolden("ClassDeclarations.golden")));
2275 6 : }
2276 :
2277 23724 : TEST(ClassAndSuperClass) {
2278 : InitializedIgnitionHandleScope scope;
2279 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2280 : printer.set_wrap(false);
2281 12 : printer.set_test_function_name("test");
2282 : const char* snippets[] = {
2283 : "var test;\n"
2284 : "(function() {\n"
2285 : " class A {\n"
2286 : " method() { return 2; }\n"
2287 : " }\n"
2288 : " class B extends A {\n"
2289 : " method() { return super.method() + 1; }\n"
2290 : " }\n"
2291 : " test = new B().method;\n"
2292 : " test();\n"
2293 : "})();\n",
2294 :
2295 : "var test;\n"
2296 : "(function() {\n"
2297 : " class A {\n"
2298 : " get x() { return 1; }\n"
2299 : " set x(val) { return; }\n"
2300 : " }\n"
2301 : " class B extends A {\n"
2302 : " method() { super.x = 2; return super.x; }\n"
2303 : " }\n"
2304 : " test = new B().method;\n"
2305 : " test();\n"
2306 : "})();\n",
2307 :
2308 : "var test;\n"
2309 : "(function() {\n"
2310 : " class A {\n"
2311 : " constructor(x) { this.x_ = x; }\n"
2312 : " }\n"
2313 : " class B extends A {\n"
2314 : " constructor() { super(1); this.y_ = 2; }\n"
2315 : " }\n"
2316 : " test = new B().constructor;\n"
2317 : "})();\n",
2318 :
2319 : "var test;\n"
2320 : "(function() {\n"
2321 : " class A {\n"
2322 : " constructor() { this.x_ = 1; }\n"
2323 : " }\n"
2324 : " class B extends A {\n"
2325 : " constructor() { super(); this.y_ = 2; }\n"
2326 : " }\n"
2327 : " test = new B().constructor;\n"
2328 : "})();\n",
2329 6 : };
2330 :
2331 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2332 : LoadGolden("ClassAndSuperClass.golden")));
2333 6 : }
2334 :
2335 23724 : TEST(Generators) {
2336 : InitializedIgnitionHandleScope scope;
2337 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2338 : printer.set_wrap(false);
2339 12 : printer.set_test_function_name("f");
2340 :
2341 : const char* snippets[] = {
2342 : "function* f() { }\n"
2343 : "f();\n",
2344 :
2345 : "function* f() { yield 42 }\n"
2346 : "f();\n",
2347 :
2348 : "function* f() { for (let x of [42]) yield x }\n"
2349 : "f();\n",
2350 :
2351 : "function* g() { yield 42 }\n"
2352 : "function* f() { yield* g() }\n"
2353 : "f();\n",
2354 6 : };
2355 :
2356 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2357 : LoadGolden("Generators.golden")));
2358 6 : }
2359 :
2360 23724 : TEST(AsyncGenerators) {
2361 6 : bool old_flag = i::FLAG_harmony_async_iteration;
2362 6 : i::FLAG_harmony_async_iteration = true;
2363 : InitializedIgnitionHandleScope scope;
2364 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2365 : printer.set_wrap(false);
2366 12 : printer.set_test_function_name("f");
2367 :
2368 : const char* snippets[] = {
2369 : "async function* f() { }\n"
2370 : "f();\n",
2371 :
2372 : "async function* f() { yield 42 }\n"
2373 : "f();\n",
2374 :
2375 : "async function* f() { for (let x of [42]) yield x }\n"
2376 : "f();\n",
2377 :
2378 : "function* g() { yield 42 }\n"
2379 : "async function* f() { yield* g() }\n"
2380 : "f();\n",
2381 6 : };
2382 :
2383 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2384 : LoadGolden("AsyncGenerators.golden")));
2385 6 : i::FLAG_harmony_async_iteration = old_flag;
2386 6 : }
2387 :
2388 23724 : TEST(Modules) {
2389 : InitializedIgnitionHandleScope scope;
2390 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2391 : printer.set_wrap(false);
2392 : printer.set_module(true);
2393 : printer.set_top_level(true);
2394 :
2395 : const char* snippets[] = {
2396 : "import \"bar\";\n",
2397 :
2398 : "import {foo} from \"bar\";\n",
2399 :
2400 : "import {foo as goo} from \"bar\";\n"
2401 : "goo(42);\n"
2402 : "{ let x; { goo(42) } };\n",
2403 :
2404 : "export var foo = 42;\n"
2405 : "foo++;\n"
2406 : "{ let x; { foo++ } };\n",
2407 :
2408 : "export let foo = 42;\n"
2409 : "foo++;\n"
2410 : "{ let x; { foo++ } };\n",
2411 :
2412 : "export const foo = 42;\n"
2413 : "foo++;\n"
2414 : "{ let x; { foo++ } };\n",
2415 :
2416 : "export default (function () {});\n",
2417 :
2418 : "export default (class {});\n",
2419 :
2420 : "export {foo as goo} from \"bar\"\n",
2421 :
2422 : "export * from \"bar\"\n",
2423 :
2424 : "import * as foo from \"bar\"\n"
2425 : "foo.f(foo, foo.x);\n",
2426 6 : };
2427 :
2428 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2429 : LoadGolden("Modules.golden")));
2430 6 : }
2431 :
2432 23724 : TEST(SuperCallAndSpread) {
2433 : InitializedIgnitionHandleScope scope;
2434 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2435 : printer.set_wrap(false);
2436 12 : printer.set_test_function_name("test");
2437 : const char* snippets[] = {
2438 : "var test;\n"
2439 : "(function() {\n"
2440 : " class A {\n"
2441 : " constructor(...args) { this.baseArgs = args; }\n"
2442 : " }\n"
2443 : " class B extends A {}\n"
2444 : " test = new B(1, 2, 3).constructor;\n"
2445 : "})();\n",
2446 :
2447 : "var test;\n"
2448 : "(function() {\n"
2449 : " class A {\n"
2450 : " constructor(...args) { this.baseArgs = args; }\n"
2451 : " }\n"
2452 : " class B extends A {\n"
2453 : " constructor(...args) { super(1, ...args); }\n"
2454 : " }\n"
2455 : " test = new B(1, 2, 3).constructor;\n"
2456 : "})();\n",
2457 :
2458 : "var test;\n"
2459 : "(function() {\n"
2460 : " class A {\n"
2461 : " constructor(...args) { this.baseArgs = args; }\n"
2462 : " }\n"
2463 : " class B extends A {\n"
2464 : " constructor(...args) { super(1, ...args, 1); }\n"
2465 : " }\n"
2466 : " test = new B(1, 2, 3).constructor;\n"
2467 : "})();\n",
2468 6 : };
2469 :
2470 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2471 : LoadGolden("SuperCallAndSpread.golden")));
2472 6 : }
2473 :
2474 23724 : TEST(CallAndSpread) {
2475 : InitializedIgnitionHandleScope scope;
2476 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2477 : const char* snippets[] = {"Math.max(...[1, 2, 3]);\n",
2478 : "Math.max(0, ...[1, 2, 3]);\n",
2479 6 : "Math.max(0, ...[1, 2, 3], 4);\n"};
2480 :
2481 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2482 : LoadGolden("CallAndSpread.golden")));
2483 6 : }
2484 :
2485 23724 : TEST(NewAndSpread) {
2486 : InitializedIgnitionHandleScope scope;
2487 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2488 : const char* snippets[] = {
2489 : "class A { constructor(...args) { this.args = args; } }\n"
2490 : "new A(...[1, 2, 3]);\n",
2491 :
2492 : "class A { constructor(...args) { this.args = args; } }\n"
2493 : "new A(0, ...[1, 2, 3]);\n",
2494 :
2495 : "class A { constructor(...args) { this.args = args; } }\n"
2496 6 : "new A(0, ...[1, 2, 3], 4);\n"};
2497 :
2498 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2499 : LoadGolden("NewAndSpread.golden")));
2500 6 : }
2501 :
2502 23724 : TEST(ForAwaitOf) {
2503 6 : bool old_flag = i::FLAG_harmony_async_iteration;
2504 6 : i::FLAG_harmony_async_iteration = true;
2505 : InitializedIgnitionHandleScope scope;
2506 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2507 : printer.set_wrap(false);
2508 12 : printer.set_test_function_name("f");
2509 :
2510 : const char* snippets[] = {
2511 : "async function f() {\n"
2512 : " for await (let x of [1, 2, 3]) {}\n"
2513 : "}\n"
2514 : "f();\n",
2515 :
2516 : "async function f() {\n"
2517 : " for await (let x of [1, 2, 3]) { return x; }\n"
2518 : "}\n"
2519 : "f();\n",
2520 :
2521 : "async function f() {\n"
2522 : " for await (let x of [10, 20, 30]) {\n"
2523 : " if (x == 10) continue;\n"
2524 : " if (x == 20) break;\n"
2525 : " }\n"
2526 : "}\n"
2527 : "f();\n",
2528 :
2529 : "async function f() {\n"
2530 : " var x = { 'a': 1, 'b': 2 };\n"
2531 : " for (x['a'] of [1,2,3]) { return x['a']; }\n"
2532 : "}\n"
2533 6 : "f();\n"};
2534 :
2535 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2536 : LoadGolden("ForAwaitOf.golden")));
2537 :
2538 6 : i::FLAG_harmony_async_iteration = old_flag;
2539 6 : }
2540 :
2541 23724 : TEST(StandardForLoop) {
2542 : InitializedIgnitionHandleScope scope;
2543 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2544 : printer.set_wrap(false);
2545 12 : printer.set_test_function_name("f");
2546 :
2547 : const char* snippets[] = {
2548 : "function f() {\n"
2549 : " for (let x = 0; x < 10; ++x) { let y = x; }\n"
2550 : "}\n"
2551 : "f();\n",
2552 :
2553 : "function f() {\n"
2554 : " for (let x = 0; x < 10; ++x) { eval('1'); }\n"
2555 : "}\n"
2556 : "f();\n",
2557 :
2558 : "function f() {\n"
2559 : " for (let x = 0; x < 10; ++x) { (function() { return x; })(); }\n"
2560 : "}\n"
2561 : "f();\n",
2562 :
2563 : "function f() {\n"
2564 : " for (let { x, y } = { x: 0, y: 3 }; y > 0; --y) { let z = x + y; }\n"
2565 : "}\n"
2566 : "f();\n",
2567 :
2568 : "function* f() {\n"
2569 : " for (let x = 0; x < 10; ++x) { let y = x; }\n"
2570 : "}\n"
2571 : "f();\n",
2572 :
2573 : "function* f() {\n"
2574 : " for (let x = 0; x < 10; ++x) yield x;\n"
2575 : "}\n"
2576 : "f();\n",
2577 :
2578 : "async function f() {\n"
2579 : " for (let x = 0; x < 10; ++x) { let y = x; }\n"
2580 : "}\n"
2581 : "f();\n",
2582 :
2583 : "async function f() {\n"
2584 : " for (let x = 0; x < 10; ++x) await x;\n"
2585 : "}\n"
2586 6 : "f();\n"};
2587 :
2588 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2589 : LoadGolden("StandardForLoop.golden")));
2590 6 : }
2591 :
2592 23724 : TEST(ForOfLoop) {
2593 : InitializedIgnitionHandleScope scope;
2594 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2595 : printer.set_wrap(false);
2596 12 : printer.set_test_function_name("f");
2597 :
2598 : const char* snippets[] = {
2599 : "function f(arr) {\n"
2600 : " for (let x of arr) { let y = x; }\n"
2601 : "}\n"
2602 : "f([1, 2, 3]);\n",
2603 :
2604 : "function f(arr) {\n"
2605 : " for (let x of arr) { eval('1'); }\n"
2606 : "}\n"
2607 : "f([1, 2, 3]);\n",
2608 :
2609 : "function f(arr) {\n"
2610 : " for (let x of arr) { (function() { return x; })(); }\n"
2611 : "}\n"
2612 : "f([1, 2, 3]);\n",
2613 :
2614 : "function f(arr) {\n"
2615 : " for (let { x, y } of arr) { let z = x + y; }\n"
2616 : "}\n"
2617 : "f([{ x: 0, y: 3 }, { x: 1, y: 9 }, { x: -12, y: 17 }]);\n",
2618 :
2619 : "function* f(arr) {\n"
2620 : " for (let x of arr) { let y = x; }\n"
2621 : "}\n"
2622 : "f([1, 2, 3]);\n",
2623 :
2624 : "function* f(arr) {\n"
2625 : " for (let x of arr) yield x;\n"
2626 : "}\n"
2627 : "f([1, 2, 3]);\n",
2628 :
2629 : "async function f(arr) {\n"
2630 : " for (let x of arr) { let y = x; }\n"
2631 : "}\n"
2632 : "f([1, 2, 3]);\n",
2633 :
2634 : "async function f(arr) {\n"
2635 : " for (let x of arr) await x;\n"
2636 : "}\n"
2637 6 : "f([1, 2, 3]);\n"};
2638 :
2639 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2640 : LoadGolden("ForOfLoop.golden")));
2641 6 : }
2642 :
2643 23724 : TEST(StringConcat) {
2644 : InitializedIgnitionHandleScope scope;
2645 6 : BytecodeExpectationsPrinter printer(CcTest::isolate());
2646 :
2647 : const char* snippets[] = {
2648 : "var a = 1;\n"
2649 : "var b = 2;\n"
2650 : "return a + b + 'string';\n",
2651 :
2652 : "var a = 1;\n"
2653 : "var b = 2;\n"
2654 : "return 'string' + a + b;\n",
2655 :
2656 : "var a = 1;\n"
2657 : "var b = 2;\n"
2658 : "return a + 'string' + b;\n",
2659 :
2660 : "var a = 1;\n"
2661 : "var b = 2;\n"
2662 : "return 'foo' + a + 'bar' + b + 'baz' + 1;\n",
2663 :
2664 : "var a = 1;\n"
2665 : "var b = 2;\n"
2666 : "return (a + 'string') + ('string' + b);\n",
2667 :
2668 : "var a = 1;\n"
2669 : "var b = 2;\n"
2670 : "function foo(a, b) { };\n"
2671 : "return 'string' + foo(a, b) + a + b;\n",
2672 6 : };
2673 :
2674 24 : CHECK(CompareTexts(BuildActual(printer, snippets),
2675 : LoadGolden("StringConcat.golden")));
2676 6 : }
2677 :
2678 : #undef XSTR
2679 : #undef STR
2680 : #undef UNIQUE_VAR
2681 : #undef REPEAT_2
2682 : #undef REPEAT_4
2683 : #undef REPEAT_8
2684 : #undef REPEAT_16
2685 : #undef REPEAT_32
2686 : #undef REPEAT_64
2687 : #undef REPEAT_128
2688 : #undef REPEAT_256
2689 : #undef REPEAT_127
2690 : #undef REPEAT_249
2691 : #undef REPEAT_2_UNIQUE_VARS
2692 : #undef REPEAT_4_UNIQUE_VARS
2693 : #undef REPEAT_8_UNIQUE_VARS
2694 : #undef REPEAT_16_UNIQUE_VARS
2695 : #undef REPEAT_32_UNIQUE_VARS
2696 : #undef REPEAT_64_UNIQUE_VARS
2697 : #undef REPEAT_128_UNIQUE_VARS
2698 : #undef REPEAT_250_UNIQUE_VARS
2699 : #undef FUNC_ARG
2700 :
2701 : } // namespace interpreter
2702 : } // namespace internal
2703 71154 : } // namespace v8
|
