OLD | NEW |
| (Empty) |
1 // Copyright 2011 the V8 project authors. All rights reserved. | |
2 // Redistribution and use in source and binary forms, with or without | |
3 // modification, are permitted provided that the following conditions are | |
4 // met: | |
5 // | |
6 // * Redistributions of source code must retain the above copyright | |
7 // notice, this list of conditions and the following disclaimer. | |
8 // * Redistributions in binary form must reproduce the above | |
9 // copyright notice, this list of conditions and the following | |
10 // disclaimer in the documentation and/or other materials provided | |
11 // with the distribution. | |
12 // * Neither the name of Google Inc. nor the names of its | |
13 // contributors may be used to endorse or promote products derived | |
14 // from this software without specific prior written permission. | |
15 // | |
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
27 | |
28 // Flags: --harmony-sloppy --harmony-sloppy-let | |
29 | |
30 // We want to test the context chain shape. In each of the tests cases | |
31 // below, the outer with is to force a runtime lookup of the identifier 'x' | |
32 // to actually verify that the inner context has been discarded. A static | |
33 // lookup of 'x' might accidentally succeed. | |
34 | |
35 { | |
36 let x = 2; | |
37 L: { | |
38 let x = 3; | |
39 assertEquals(3, x); | |
40 break L; | |
41 assertTrue(false); | |
42 } | |
43 assertEquals(2, x); | |
44 } | |
45 | |
46 do { | |
47 let x = 4; | |
48 assertEquals(4,x); | |
49 { | |
50 let x = 5; | |
51 assertEquals(5, x); | |
52 continue; | |
53 assertTrue(false); | |
54 } | |
55 } while (false); | |
56 | |
57 var caught = false; | |
58 try { | |
59 { | |
60 let xx = 18; | |
61 throw 25; | |
62 assertTrue(false); | |
63 } | |
64 } catch (e) { | |
65 caught = true; | |
66 assertEquals(25, e); | |
67 (function () { | |
68 try { | |
69 // NOTE: This checks that the block scope containing xx has been | |
70 // removed from the context chain. | |
71 eval('xx'); | |
72 assertTrue(false); // should not reach here | |
73 } catch (e2) { | |
74 assertTrue(e2 instanceof ReferenceError); | |
75 } | |
76 })(); | |
77 } | |
78 assertTrue(caught); | |
79 | |
80 | |
81 (function(x) { | |
82 label: { | |
83 let x = 'inner'; | |
84 break label; | |
85 } | |
86 assertEquals('outer', eval('x')); | |
87 })('outer'); | |
88 | |
89 | |
90 (function(x) { | |
91 label: { | |
92 let x = 'middle'; | |
93 { | |
94 let x = 'inner'; | |
95 break label; | |
96 } | |
97 } | |
98 assertEquals('outer', eval('x')); | |
99 })('outer'); | |
100 | |
101 | |
102 (function(x) { | |
103 for (var i = 0; i < 10; ++i) { | |
104 let x = 'inner' + i; | |
105 continue; | |
106 } | |
107 assertEquals('outer', eval('x')); | |
108 })('outer'); | |
109 | |
110 | |
111 (function(x) { | |
112 label: for (var i = 0; i < 10; ++i) { | |
113 let x = 'middle' + i; | |
114 for (var j = 0; j < 10; ++j) { | |
115 let x = 'inner' + j; | |
116 continue label; | |
117 } | |
118 } | |
119 assertEquals('outer', eval('x')); | |
120 })('outer'); | |
121 | |
122 | |
123 (function(x) { | |
124 try { | |
125 let x = 'inner'; | |
126 throw 0; | |
127 } catch (e) { | |
128 assertEquals('outer', eval('x')); | |
129 } | |
130 })('outer'); | |
131 | |
132 | |
133 (function(x) { | |
134 try { | |
135 let x = 'middle'; | |
136 { | |
137 let x = 'inner'; | |
138 throw 0; | |
139 } | |
140 } catch (e) { | |
141 assertEquals('outer', eval('x')); | |
142 } | |
143 })('outer'); | |
144 | |
145 | |
146 try { | |
147 (function(x) { | |
148 try { | |
149 let x = 'inner'; | |
150 throw 0; | |
151 } finally { | |
152 assertEquals('outer', eval('x')); | |
153 } | |
154 })('outer'); | |
155 } catch (e) { | |
156 if (e instanceof MjsUnitAssertionError) throw e; | |
157 } | |
158 | |
159 | |
160 try { | |
161 (function(x) { | |
162 try { | |
163 let x = 'middle'; | |
164 { | |
165 let x = 'inner'; | |
166 throw 0; | |
167 } | |
168 } finally { | |
169 assertEquals('outer', eval('x')); | |
170 } | |
171 })('outer'); | |
172 } catch (e) { | |
173 if (e instanceof MjsUnitAssertionError) throw e; | |
174 } | |
175 | |
176 | |
177 // Verify that the context is correctly set in the stack frame after exiting | |
178 // from eval. | |
179 function f() {} | |
180 | |
181 (function(x) { | |
182 label: { | |
183 let x = 'inner'; | |
184 break label; | |
185 } | |
186 f(); // The context could be restored from the stack after the call. | |
187 assertEquals('outer', eval('x')); | |
188 })('outer'); | |
189 | |
190 | |
191 (function(x) { | |
192 for (var i = 0; i < 10; ++i) { | |
193 let x = 'inner'; | |
194 continue; | |
195 } | |
196 f(); | |
197 assertEquals('outer', eval('x')); | |
198 })('outer'); | |
199 | |
200 | |
201 (function(x) { | |
202 try { | |
203 let x = 'inner'; | |
204 throw 0; | |
205 } catch (e) { | |
206 f(); | |
207 assertEquals('outer', eval('x')); | |
208 } | |
209 })('outer'); | |
210 | |
211 | |
212 try { | |
213 (function(x) { | |
214 try { | |
215 let x = 'inner'; | |
216 throw 0; | |
217 } finally { | |
218 f(); | |
219 assertEquals('outer', eval('x')); | |
220 } | |
221 })('outer'); | |
222 } catch (e) { | |
223 if (e instanceof MjsUnitAssertionError) throw e; | |
224 } | |
OLD | NEW |