jdk-24/nashorn/test/script/basic/NASHORN-207_2.js

/*
 * 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);
    }
}