[ARM,MIPS] Skip slow tests
[WebKit-https.git] / JSTests / stress / block-scoped-function-declarations.js
1 "use strict";
2
3 function assert(b) {
4     if (!b)
5         throw new Error("Bad assertion")
6 }
7
8 function test(f) {
9     for (let i = 0; i < 500; i++)
10         f();
11 }
12
13 {
14     let called = false;
15     function foo() {
16         called = true;
17         function bar() { return 25; }
18         assert(bar() === 25);
19         {
20             function bar() { return 30; }
21             assert(bar() === 30);
22         }
23         assert(bar() === 25);
24     }
25     test(foo);
26     assert(called);
27 }
28
29 {
30     let called = false;
31     function foo() {
32         called = true;
33         assert(bar() === 25);
34         {
35             assert(bar() === 30);
36             function bar() { return 30; }
37         }
38         assert(bar() === 25);
39
40         function bar() { return 25; }
41     }
42     test(foo);
43     assert(called);
44 }
45
46 {
47     let called = false;
48     function foo() {
49         called = true;
50         function foo() { return bar(); }
51         function bar() { return 25; }
52         assert(bar() === 25);
53         assert(foo() === 25);
54         {
55             function bar() { return 30; }
56             function foo() { return 25; }
57             assert(bar() === 30);
58             assert(foo() === 25);
59         }
60         assert(bar() === 25);
61         assert(foo() === 25);
62     }
63     test(foo);
64     assert(called);
65 }
66
67 {
68     let called = false;
69     function foo() {
70         called = true;
71         assert(bar() === 25);
72         assert(foo() === 25);
73         {
74             function bar() { return 30; }
75             function foo() { return 25; }
76             assert(bar() === 30);
77             assert(foo() === 25);
78         }
79         assert(bar() === 25);
80         assert(foo() === 25);
81
82         function foo() { return bar(); }
83         function bar() { return 25; }
84     }
85     test(foo);
86     assert(called);
87 }
88
89 {
90     let called = false;
91     function foo() {
92         called = true;
93         let isDefault = false;
94         switch ('foo') {
95         case 1:
96             function foo() { return 25; }
97             break;
98         case 2:
99             function bar() { return 30; }
100             break;
101         default:
102             isDefault = true;
103             assert(foo() === 25);
104             assert(bar() === 30);
105             break;
106         }
107         assert(isDefault);
108     }
109     test(foo);
110     assert(called);
111 }
112
113 {
114     let called = false;
115     function foo() {
116         called = true;
117         let is1 = false;
118         switch (1) {
119         case 1:
120             is1 = true;
121             function foo() { return 25; }
122             assert(foo() === 25);
123             assert(bar() === 30);
124             break;
125         case 2:
126             function bar() { return 30; }
127             break;
128         }
129         assert(is1);
130     }
131     test(foo);
132     assert(called);
133 }
134
135 {
136     let called = false;
137     function foo() {
138         called = true;
139         function foo() { return 25; }
140         function bar() { return "bar"; }
141         let is2 = false;
142         switch (2) {
143         case 1: {
144             function foo() { return 30; }
145             break;
146         }
147         case 2:
148             is2 = true;
149             function bar() { return 30; }
150             assert(bar() === 30);
151             assert(foo() === 25);
152             break;
153         }
154         assert(is2);
155         assert(bar() === "bar");
156         assert(foo() === 25);
157     }
158     test(foo);
159     assert(called);
160 }
161
162 {
163     let called = false;
164     function foo() {
165         called = true;
166         function foo() { return 25; }
167         function bar() { return "bar"; }
168         let capture = () => foo + "" + bar;
169         let is2 = false;
170         switch (2) {
171         case 1: {
172             function foo() { return 30; }
173             break;
174         }
175         case 2:
176             is2 = true;
177             function bar() { return 30; }
178             let capture = () => bar;
179             assert(bar() === 30);
180             assert(foo() === 25);
181             break;
182         }
183         assert(is2);
184         assert(bar() === "bar");
185         assert(foo() === 25);
186     }
187     test(foo);
188     assert(called);
189 }
190
191 {
192     let called = false;
193     function foo() {
194         called = true;
195         let f1;
196         let f2 = foo;
197         function foo() { }
198         if (true) {
199             f1 = foo;
200             function foo() { }
201         }
202         assert(!!f1 && !!f2);
203         assert(f1 !== f2);
204     }
205     test(foo);
206     assert(called);
207 }
208
209 {
210     let called = false;
211     function foo() {
212         called = true;
213         let f1;
214         let f2 = foo;
215         function foo() { }
216         let capture = () => foo;
217         if (true) {
218             f1 = foo;
219             function foo() { }
220             let capture = () => foo;
221         }
222         assert(!!f1 && !!f2);
223         assert(f1 !== f2);
224     }
225     test(foo);
226     assert(called);
227 }