| /* |
| * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /** |
| * NASHORN-207 : Implement strict mode. |
| * |
| * @test |
| * @run |
| */ |
| |
| // make sure that 'use strict' as first directive inside eval |
| // also works the same way (as eval called from strict mode caller). |
| |
| try { |
| eval("'use strict'; foo = 4;"); |
| fail("#1 should have thrown ReferenceError"); |
| } catch (e) { |
| if (! (e instanceof ReferenceError)) { |
| fail("#2 expected ReferenceError but got " + e); |
| } |
| } |
| |
| if (typeof foo !== 'undefined') { |
| fail("#3 strict mode eval defined var in global scope!"); |
| } |
| |
| try { |
| eval("'use strict'; var let = 23;"); |
| fail("#4 should have thrown SyntaxError"); |
| } catch (e) { |
| if (! (e instanceof SyntaxError)) { |
| fail("#5 SyntaxError expected but got " + e); |
| } |
| } |
| |
| // non-strict mode, some of the future reserved words can be used |
| // as identifiers. These include "let", "implements", "yield" etc. |
| var let = 30; |
| var implements = "hello"; |
| function yield() {} |
| function public() {} |
| var private = false; |
| var protected = "hello"; |
| var interface = "interface"; |
| function f(package) {} |
| function static() {} |
| |
| // in strict mode, arguments does not alias named access |
| function func(x, y) { |
| 'use strict'; |
| |
| if (x !== arguments[0]) { |
| fail("#6 arguments[0] !== x"); |
| } |
| |
| if (y !== arguments[1]) { |
| fail("#7 arguments[1] !== y"); |
| } |
| |
| arguments[0] = 1; |
| arguments[1] = 2; |
| |
| if (x === arguments[0]) { |
| fail("#8 arguments[0] === x after assignment to it"); |
| } |
| |
| if (y === arguments[1]) { |
| fail("#9 arguments[1] === y after assignment to it "); |
| } |
| } |
| |
| func(); |
| |
| // functions can not be declared everywhere!! |
| try { |
| eval("'use strict'; if (true) { function func() {} }"); |
| fail("#10 should have thrown SyntaxError"); |
| } catch (e) { |
| if (! (e instanceof SyntaxError)) { |
| fail("#11 SyntaxError expected got " + e); |
| } |
| } |
| |
| // arguments.caller and arguments.callee can't read or written in strict mode |
| function func2() { |
| 'use strict'; |
| |
| try { |
| print(arguments.callee); |
| fail("#12 arguments.callee should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#13 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| print(arguments.caller); |
| fail("#14 arguments.caller should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#15 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| arguments.caller = 10; |
| fail("#16 arguments.caller assign should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#17 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| arguments.callee = true; |
| fail("#18 arguments.callee assign should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#19 TypeError expected, got " + e); |
| } |
| } |
| } |
| |
| func2(); |
| |
| // func.caller and func.arguments can't read or written in strict mode |
| function func3() { |
| 'use strict'; |
| |
| try { |
| print(func3.arguments); |
| fail("#20 func.arguments should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#21 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| print(func3.caller); |
| fail("#22 func3.caller should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#23 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| func3.arguments = 10; |
| fail("#24 func3.arguments assign should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#25 TypeError expected, got " + e); |
| } |
| } |
| |
| try { |
| func3.caller = true; |
| fail("#26 func3.caller assign should have thrown TypeError"); |
| } catch (e) { |
| if (! (e instanceof TypeError)) { |
| fail("#27 TypeError expected, got " + e); |
| } |
| } |
| } |
| |
| func3(); |
| |
| try { |
| eval("function eval() { 'use strict'; }"); |
| fail("#28 should have thrown SyntaxError"); |
| } catch (e) { |
| if (! (e instanceof SyntaxError)) { |
| fail("#29 SyntaxError expected, got " + e); |
| } |
| } |
| |
| function func4() { |
| 'use \ |
| strict'; |
| |
| // The use strict directive can't contain line continuation. |
| // So this is not a strict mode function!! |
| with({}) {} |
| } |
| |
| func4(); |
| |
| function func5() { |
| 'use\u2028strict'; |
| |
| // The use strict directive can't contain unicode whitespace escapes |
| // So this is not a strict mode function!! |
| with({}) {} |
| } |
| |
| func5(); |
| |
| function func6() { |
| 'use\u2029strict'; |
| |
| // The use strict directive can't contain unicode whitespace escapes |
| // So this is not a strict mode function!! |
| with({}) {} |
| } |
| |
| func6(); |
| |
| try { |
| eval("'bogus directive'; 'use strict'; eval = 10"); |
| fail("#30 SyntaxError expected from eval"); |
| } catch (e) { |
| if (! (e instanceof SyntaxError)) { |
| fail("#31 SyntaxError expected but got " + e); |
| } |
| } |