NASHORN-207_2.js revision 877:cf4d2252d444 
1/*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/**
25 * NASHORN-207 : Implement strict mode.
26 *
27 * @test
28 * @run
29 */
30
31// make sure that 'use strict' as first directive inside eval
32// also works the same way (as eval called from strict mode caller).
33
34try {
35    eval("'use strict'; foo = 4;");
36    fail("#1 should have thrown ReferenceError");
37} catch (e) {
38    if (! (e instanceof ReferenceError)) {
39        fail("#2 expected ReferenceError but got " + e);
40    }
41}
42
43if (typeof foo !== 'undefined') {
44    fail("#3 strict mode eval defined var in global scope!");
45}
46
47try {
48    eval("'use strict'; var let = 23;");
49    fail("#4 should have thrown SyntaxError");
50} catch (e) {
51    if (! (e instanceof SyntaxError)) {
52        fail("#5 SyntaxError expected but got " + e);
53    }
54}
55
56// non-strict mode, some of the future reserved words can be used
57// as identifiers. These include "let", "implements", "yield" etc.
58var let = 30;
59var implements = "hello";
60function yield() {}
61function public() {}
62var private = false;
63var protected = "hello";
64var interface = "interface";
65function f(package) {}
66function static() {}
67
68// in strict mode, arguments does not alias named access
69function func(x, y) {
70    'use strict';
71
72    if (x !== arguments[0]) {
73        fail("#6 arguments[0] !== x");
74    }
75
76    if (y !== arguments[1]) {
77        fail("#7 arguments[1] !== y");
78    }
79
80    arguments[0] = 1;
81    arguments[1] = 2;
82
83    if (x === arguments[0]) {
84        fail("#8 arguments[0] === x after assignment to it");
85    }
86
87    if (y === arguments[1]) {
88        fail("#9 arguments[1] === y after assignment to it ");
89    }
90}
91
92func();
93
94// functions can not be declared everywhere!!
95try {
96    eval("'use strict'; if (true) { function func() {} }");
97    fail("#10 should have thrown SyntaxError");
98} catch (e) {
99    if (! (e instanceof SyntaxError)) {
100        fail("#11 SyntaxError expected got " + e);
101    }
102}
103
104// arguments.caller and arguments.callee can't read or written in strict mode
105function func2() {
106    'use strict';
107
108    try {
109        print(arguments.callee);
110        fail("#12 arguments.callee should have thrown TypeError");
111    } catch (e) {
112        if (! (e instanceof TypeError)) {
113            fail("#13 TypeError expected, got " + e);
114        }
115    }
116
117    try {
118        print(arguments.caller);
119        fail("#14 arguments.caller should have thrown TypeError");
120    } catch (e) {
121        if (! (e instanceof TypeError)) {
122            fail("#15 TypeError expected, got " + e);
123        }
124    }
125
126    try {
127        arguments.caller = 10;
128        fail("#16 arguments.caller assign should have thrown TypeError");
129    } catch (e) {
130        if (! (e instanceof TypeError)) {
131            fail("#17 TypeError expected, got " + e);
132        }
133    }
134
135    try {
136        arguments.callee = true;
137        fail("#18 arguments.callee assign should have thrown TypeError");
138    } catch (e) {
139        if (! (e instanceof TypeError)) {
140            fail("#19 TypeError expected, got " + e);
141        }
142    }
143}
144
145func2();
146
147// func.caller and func.arguments can't read or written in strict mode
148function func3() {
149    'use strict';
150
151    try {
152        print(func3.arguments);
153        fail("#20 func.arguments should have thrown TypeError");
154    } catch (e) {
155        if (! (e instanceof TypeError)) {
156            fail("#21 TypeError expected, got " + e);
157        }
158    }
159
160    try {
161        print(func3.caller);
162        fail("#22 func3.caller should have thrown TypeError");
163    } catch (e) {
164        if (! (e instanceof TypeError)) {
165            fail("#23 TypeError expected, got " + e);
166        }
167    }
168
169    try {
170        func3.arguments = 10;
171        fail("#24 func3.arguments assign should have thrown TypeError");
172    } catch (e) {
173        if (! (e instanceof TypeError)) {
174            fail("#25 TypeError expected, got " + e);
175        }
176    }
177
178    try {
179        func3.caller = true;
180        fail("#26 func3.caller assign should have thrown TypeError");
181    } catch (e) {
182        if (! (e instanceof TypeError)) {
183            fail("#27 TypeError expected, got " + e);
184        }
185    }
186}
187
188func3();
189
190try {
191    eval("function eval() { 'use strict'; }");
192    fail("#28 should have thrown SyntaxError");
193} catch (e) {
194    if (! (e instanceof SyntaxError)) {
195        fail("#29 SyntaxError expected, got " + e);
196    }
197}
198
199function func4() {
200  'use \
201strict';
202
203    // The use strict directive can't contain line continuation.
204    // So this is not a strict mode function!!
205    with({}) {}
206}
207
208func4();
209
210function func5() {
211   'use\u2028strict';
212
213    // The use strict directive can't contain unicode whitespace escapes
214    // So this is not a strict mode function!!
215    with({}) {}
216}
217
218func5();
219
220function func6() {
221   'use\u2029strict';
222
223    // The use strict directive can't contain unicode whitespace escapes
224    // So this is not a strict mode function!!
225    with({}) {}
226}
227
228func6();
229
230try {
231    eval("'bogus directive'; 'use strict'; eval = 10");
232    fail("#30 SyntaxError expected from eval");
233} catch (e) {
234    if (! (e instanceof SyntaxError)) {
235        fail("#31 SyntaxError expected but got " + e);
236    }
237}
238