//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

// ES6 restricted property tests

WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");

function verifyAttributes(obj, prop, attribs, name) {
    var p = Object.getOwnPropertyDescriptor(obj, prop);

    assert.areNotEqual(undefined, p, name + " does not have property named " + prop);

    assert.areEqual(attribs.writable, p.writable, name + " has property named " + prop + " with writable = " + attribs.writable);
    assert.areEqual(attribs.enumerable, p.enumerable, name + " has property named " + prop + " with enumerable = " + attribs.enumerable);
    assert.areEqual(attribs.configurable, p.configurable, name + " has property named " + prop + " with configurable = " + attribs.configurable);
}

function verifyHasRestrictedOwnProperties(obj, name) {
    assert.isTrue(obj.hasOwnProperty('caller'), name + " reports that it has own property 'caller'")
    assert.isTrue(obj.hasOwnProperty('arguments'), name + " reports that it has own property 'arguments'")

    var names = Object.getOwnPropertyNames(obj);
    assert.areNotEqual(-1, names.findIndex((e) => { return e === 'arguments'; }), name + " has 'arguments' own property");
    assert.areNotEqual(-1, names.findIndex((e) => { return e === 'caller'; }), name + " has 'caller' own property");

    verifyAttributes(obj, 'caller', { writable: false, enumerable: false, configurable: false }, name);
    assert.isFalse(obj.propertyIsEnumerable('caller'), name + " says 'caller' property is not enumerable");
    verifyAttributes(obj, 'arguments', { writable: false, enumerable: false, configurable: false }, name);
    assert.isFalse(obj.propertyIsEnumerable('arguments'), name + " says 'arguments' property is not enumerable");

    assert.areEqual(null, obj.caller, name + " says 'caller' property is null")
    assert.areEqual(null, obj.arguments, name + " says 'arguments' property is null")

    assert.doesNotThrow(function() { obj.caller = 'something'; }, name + " has 'caller' property which can't be assigned to");
    assert.doesNotThrow(function() { obj.arguments = 'something'; }, name + " has 'arguments' property which  can't be assigned to");

    assert.throws(function() { 'use strict'; obj.caller = 'something'; }, TypeError, name + " has 'caller' own property but it is not configurable so we will throw in strict mode", "Assignment to read-only properties is not allowed in strict mode");
    assert.throws(function() { 'use strict'; obj.arguments = 'something'; }, TypeError, name + " has 'arguments' own property but it is not configurable so we will throw in strict mode", "Assignment to read-only properties is not allowed in strict mode");

    assert.areEqual(null, obj.caller, name + " says 'caller' property is null")
    assert.areEqual(null, obj.arguments, name + " says 'arguments' property is null")

    assert.throws(function() { Object.defineProperty(obj, 'arguments', { value: 123 }); }, TypeError, name + " has 'arguments' property as non-writable, non-configurable", "Cannot modify non-writable property 'arguments'");
    assert.throws(function() { Object.defineProperty(obj, 'caller', { value: 123 }); }, TypeError, name + " has 'caller' property as non-writable, non-configurable", "Cannot modify non-writable property 'caller'");

    assert.isFalse(delete obj.arguments, name + " has 'arguments' property as non-configurable so delete returns false");
    assert.isFalse(delete obj.caller, name + " has 'caller' property as non-configurable so delete returns false");

    assert.throws(function() { 'use strict'; delete obj.caller; }, TypeError, name + " has 'caller' own property but it is not configurable so we will throw in strict mode", "Calling delete on 'caller' is not allowed in strict mode");
    assert.throws(function() { 'use strict'; delete obj.arguments; }, TypeError, name + " has 'arguments' own property but it is not configurable so we will throw in strict mode", "Calling delete on 'arguments' is not allowed in strict mode");
}

function verifyDoesNotHaveRestrictedOwnProperties(obj, name) {
    assert.isFalse(obj.hasOwnProperty('caller'), name + " does not report that it has own property 'caller'")
    assert.isFalse(obj.hasOwnProperty('arguments'), name + " does not report that it has own property 'arguments'")

    var names = Object.getOwnPropertyNames(obj);
    assert.areEqual(-1, names.findIndex((e) => { return e === 'arguments'; }), name + " does not have 'arguments' own property");
    assert.areEqual(-1, names.findIndex((e) => { return e === 'caller'; }), name + " does not have 'caller' own property");

    assert.areEqual(undefined, Object.getOwnPropertyDescriptor(obj, 'caller'), name + " does not have 'caller' own property")
    assert.isFalse(obj.propertyIsEnumerable('caller'), name + " says 'caller' property is not enumerable");
    assert.areEqual(undefined, Object.getOwnPropertyDescriptor(obj, 'arguments'), name + " does not have 'arguments' own property");
    assert.isFalse(obj.propertyIsEnumerable('arguments'), name + " says 'arguments' property is not enumerable");

    assert.throws(function() { obj.caller; }, TypeError, name + " throws on access to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
    assert.throws(function() { obj.arguments; }, TypeError, name + " throws on access to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

    assert.throws(function() { 'use strict'; obj.caller; }, TypeError, name + " throws on access to 'caller' property in strict mode", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
    assert.throws(function() { 'use strict'; obj.arguments; }, TypeError, name + " throws on access to 'arguments' property in strict mode", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

    assert.throws(function() { obj.caller = 'something'; }, TypeError, name + " throws trying to assign to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
    assert.throws(function() { obj.arguments = 'something'; }, TypeError, name + " throws trying to assign to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

    assert.throws(function() { 'use strict'; obj.caller = 'something'; }, TypeError, name + " throws trying to assign to 'caller' property in strict mode", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
    assert.throws(function() { 'use strict'; obj.arguments = 'something'; }, TypeError, name + " throws trying to assign to 'arguments' property in strict mode", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

    assert.isTrue(delete obj.arguments, name + " allows deleting own property named 'arguments' if that property doesn't exist");
    assert.doesNotThrow(function() { Object.defineProperty(obj, 'arguments', { value: 123, writable: true, enumerable: true, configurable: true }); }, name + " doesn't have own 'arguments' property");
    assert.isTrue(obj.hasOwnProperty('arguments'), name + " has own property 'arguments' after defineProperty")
    assert.isTrue(obj.propertyIsEnumerable('arguments'), name + " says 'arguments' property is enumerable if it is an enumerable own property");
    assert.areEqual(123, obj.arguments, name + " can have an own property defined for 'arguments'")
    verifyAttributes(obj, 'arguments', { writable: true, enumerable: true, configurable: true }, name);
    assert.isTrue(delete obj.arguments, name + " allows deleting own property named 'arguments' if that property does exist");
    assert.isFalse(obj.hasOwnProperty('arguments'), name + " doesn't have own property 'arguments' after delete")

    assert.isTrue(delete obj.caller, name + " allows deleting own property named 'caller' if that property doesn't exist");
    assert.doesNotThrow(function() { Object.defineProperty(obj, 'caller', { value: 123, writable: true, enumerable: true, configurable: true }); }, name + " doesn't have own 'caller' property");
    assert.isTrue(obj.hasOwnProperty('caller'), name + " has own property 'caller' after defineProperty")
    assert.isTrue(obj.propertyIsEnumerable('caller'), name + " says 'caller' property is enumerable if it is an enumerable own property");
    assert.areEqual(123, obj.caller, name + " can have an own property defined for 'caller'")
    verifyAttributes(obj, 'caller', { writable: true, enumerable: true, configurable: true }, name);
    assert.isTrue(delete obj.caller, name + " allows deleting own property named 'caller' if that property does exist");
    assert.isFalse(obj.hasOwnProperty('caller'), name + " doesn't have own property 'caller' after delete")

    // Remove Function.prototype from the prototype chain.
    Object.setPrototypeOf(obj, Object.prototype);
    assert.areEqual(undefined, obj.arguments, name + " does not initially have 'arguments' property when disconnected from Function.prototype");
    assert.doesNotThrow(function() { obj.arguments = 'abc'; }, name + " can set the 'arguments' property when disconnected from Function.prototype");
    assert.areEqual('abc', obj.arguments, name + " can set the 'arguments' property when disconnected from Function.prototype");
    assert.isTrue(obj.hasOwnProperty('arguments'), name + " has 'arguments' own property")
    assert.isTrue(obj.propertyIsEnumerable('arguments'), name + " says 'arguments' property is enumerable if it is an enumerable own property");
    verifyAttributes(obj, 'arguments', { writable: true, enumerable: true, configurable: true }, name);
    assert.isTrue(delete obj.arguments, name + " allows deleting own property named 'arguments' if that property does exist");
    assert.isFalse(obj.hasOwnProperty('arguments'), name + " doesn't have own property 'arguments' after delete")

    assert.areEqual(undefined, obj.caller, name + " does not initially have 'caller' property when disconnected from Function.prototype");
    assert.doesNotThrow(function() { obj.caller = 'abc'; }, name + " can set the 'caller' property when disconnected from Function.prototype");
    assert.areEqual('abc', obj.caller, name + " can set the 'caller' property when disconnected from Function.prototype");
    assert.isTrue(obj.hasOwnProperty('caller'), name + " has 'caller' own property")
    assert.isTrue(obj.propertyIsEnumerable('caller'), name + " says 'caller' property is enumerable if it is an enumerable own property");
    verifyAttributes(obj, 'caller', { writable: true, enumerable: true, configurable: true }, name);
    assert.isTrue(delete obj.caller, name + " allows deleting own property named 'caller' if that property does exist");
    assert.isFalse(obj.hasOwnProperty('caller'), name + " doesn't have own property 'caller' after delete")
}

var tests = [
    {
        name: "Restricted properties of Function.prototype",
        body: function () {
            var obj = Function.prototype;

            assert.isTrue(obj.hasOwnProperty('caller'), "Function.prototype has own property 'caller'")
            assert.isTrue(obj.hasOwnProperty('arguments'), "Function.prototype has own property 'arguments'")

            var p = Object.getOwnPropertyDescriptor(obj, 'caller');
            assert.isFalse(p.enumerable, "Function.prototype function has 'caller' own property which is not enumerable");
            assert.isFalse(p.configurable, "Function.prototype function has 'caller' own property which is not configurable");
            assert.isFalse(obj.propertyIsEnumerable('caller'), "Function.prototype says 'caller' property is not enumerable");
            assert.areEqual('function', typeof p.get, "Function.prototype['caller'] has get accessor function");
            assert.areEqual('function', typeof p.set, "Function.prototype['caller'] has set accessor function");
            assert.throws(function() { p.get(); }, TypeError, "Function.prototype['caller'] has get accessor which throws");
            assert.throws(function() { p.set(); }, TypeError, "Function.prototype['caller'] has set accessor which throws");
            assert.isTrue(p.get === p.set, "Function.prototype returns the same ThrowTypeError function for get/set accessor of 'caller' property");

            var p2 = Object.getOwnPropertyDescriptor(obj, 'arguments');
            assert.isFalse(p2.enumerable, "Function.prototype function has 'arguments' own property which is not enumerable");
            assert.isFalse(p2.configurable, "Function.prototype function has 'arguments' own property which is not configurable");
            assert.isFalse(obj.propertyIsEnumerable('arguments'), "Function.prototype says 'arguments' property is not enumerable");
            assert.areEqual('function', typeof p2.get, "Function.prototype['arguments'] has get accessor function");
            assert.areEqual('function', typeof p2.set, "Function.prototype['arguments'] has set accessor function");
            assert.throws(function() { p2.get(); }, TypeError, "Function.prototype['arguments'] has get accessor which throws");
            assert.throws(function() { p2.set(); }, TypeError, "Function.prototype['arguments'] has set accessor which throws");
            assert.isTrue(p2.get === p2.set, "Function.prototype returns the same ThrowTypeError function for get/set accessor of 'arguments' property");

            assert.isTrue(p.get === p2.get, "Function.prototype returns the same ThrowTypeError function for accessor of both 'arguments' and 'caller' properties");

            var names = Object.getOwnPropertyNames(obj);
            assert.areNotEqual(-1, names.findIndex((e) => { return e === 'arguments'; }), "Function.prototype has 'arguments' own property");
            assert.areNotEqual(-1, names.findIndex((e) => { return e === 'caller'; }), "Function.prototype has 'caller' own property");

            assert.throws(function() { obj.caller; }, TypeError, "Function.prototype throws on access to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
            assert.throws(function() { obj.arguments; }, TypeError, "Function.prototype throws on access to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

            assert.throws(function() { obj.caller = 'something'; }, TypeError, "Function.prototype throws trying to assign to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
            assert.throws(function() { obj.arguments = 'something'; }, TypeError, "Function.prototype throws trying to assign to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

            // TODO: These descriptors should have configurable set to true so remaining asserts in this test should actually succeed
            assert.throws(function() { Object.defineProperty(obj, 'arguments', { value: 123 }); }, TypeError, "Function.prototype has 'arguments' property as non-configurable", "Cannot redefine non-configurable property 'arguments'");
            assert.throws(function() { Object.defineProperty(obj, 'caller', { value: 123 }); }, TypeError, "Function.prototype has 'caller' property as non-configurable", "Cannot redefine non-configurable property 'caller'");

            assert.isFalse(delete obj.arguments, "Function.prototype has 'arguments' property as non-configurable so delete returns false");
            assert.isFalse(delete obj.caller, "Function.prototype has 'caller' property as non-configurable so delete returns false");

            assert.throws(function() { 'use strict'; delete obj.caller; }, TypeError, "Function.prototype has 'caller' own property but it is not configurable so we will throw in strict mode", "Calling delete on 'caller' is not allowed in strict mode");
            assert.throws(function() { 'use strict'; delete obj.arguments; }, TypeError, "Function.prototype has 'arguments' own property but it is not configurable so we will throw in strict mode", "Calling delete on 'arguments' is not allowed in strict mode");
        }
    },
    {
        name: "Restricted properties of non-strict function",
        body: function () {
            function obj() {};

            verifyHasRestrictedOwnProperties(obj, "Non-strict function");
        }
    },
    {
        name: "Restricted properties of strict function",
        body: function () {
            function foo() { 'use strict'; };

            verifyDoesNotHaveRestrictedOwnProperties(foo, "Strict function");
        }
    },
    {
        name: "Restricted properties of class",
        body: function () {
            class A { };

            verifyDoesNotHaveRestrictedOwnProperties(A, "Class");
        }
    },
    {
        name: "Restricted properties of class static method",
        body: function () {
            class A {
                static static_method() { }
            };

            verifyDoesNotHaveRestrictedOwnProperties(A.static_method, "Class static method");
        }
    },
    {
        name: "Restricted properties of strict-mode class static method",
        body: function () {
            class A {
                static static_method() { 'use strict'; }
            };

            verifyDoesNotHaveRestrictedOwnProperties(A.static_method, "Class strict-mode static method");
        }
    },
    {
        name: "Restricted properties of class method",
        body: function () {
            class A {
                method() { }
            };

            verifyDoesNotHaveRestrictedOwnProperties(A.prototype.method, "Class method");
        }
    },
    {
        name: "Restricted properties of strict-mode class method",
        body: function () {
            class A {
                method() { 'use strict'; }
            };

            verifyDoesNotHaveRestrictedOwnProperties(A.prototype.method, "Class strict-mode method");
        }
    },
    {
        name: "Restricted properties of class with 'caller' static method",
        body: function () {
            var obj = class A {
                static caller() { return 42; }
            };

            assert.isTrue(obj.hasOwnProperty('caller'), "Class does has own property 'caller'")
            assert.isFalse(obj.hasOwnProperty('arguments'), "Class does not report that it has own property 'arguments'")

            assert.areEqual('{"writable":true,"enumerable":false,"configurable":true}', JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'caller')), "Class does not have 'caller' own property")
            assert.areEqual(undefined, JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'arguments')), "Class does not have 'arguments' own property");
            assert.areEqual('["caller","length","name","prototype"]', JSON.stringify(Object.getOwnPropertyNames(obj).sort()), "Class does not have 'caller' and 'arguments' own properties");

            assert.areEqual(42, obj.caller(), "Accessing the 'caller' property is not restricted");
            assert.throws(function() { obj.arguments; }, TypeError, "Class throws on access to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
        }
    },
    {
        name: "Restricted properties of class with 'arguments' static get method",
        body: function () {
            var obj = class A {
                static get arguments() { return 42; }
            };

            assert.isFalse(obj.hasOwnProperty('caller'), "Class does not report that it has own property 'caller'")
            assert.isTrue(obj.hasOwnProperty('arguments'), "Class has own property 'arguments'")

            assert.areEqual(undefined, JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'caller')), "Class does not have 'caller' own property")
            assert.areEqual('{"enumerable":false,"configurable":true}', JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'arguments')), "Class has 'arguments' own property");
            assert.areEqual('["arguments","length","name","prototype"]', JSON.stringify(Object.getOwnPropertyNames(obj).sort()), "Class has 'arguments' own property, no 'caller' own property");

            assert.throws(function() { obj.caller; }, TypeError, "Class method throws on access to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
            assert.areEqual(42, obj.arguments, "Accessing the 'arguments' property is not restricted");
        }
    },
    {
        name: "Restricted properties of class with 'arguments' set method",
        body: function () {
            var my_v;
            class A {
                set arguments(v) { my_v = v; }
            };
            var obj = A;

            assert.isFalse(obj.hasOwnProperty('caller'), "Class does not report that it has own property 'caller'")
            assert.isFalse(obj.hasOwnProperty('arguments'), "Class does not report that it has own property 'arguments'")

            assert.areEqual(undefined, JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'caller')), "Class does not have 'caller' own property")
            assert.areEqual(undefined, JSON.stringify(Object.getOwnPropertyDescriptor(obj, 'arguments')), "Class has 'arguments' own property");
            assert.areEqual('["length","name","prototype"]', JSON.stringify(Object.getOwnPropertyNames(obj).sort()), "Class has 'arguments' own property, no 'caller' own property");

            assert.throws(function() { obj.caller; }, TypeError, "Class method throws on access to 'caller' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");
            assert.throws(function() { obj.arguments; }, TypeError, "Class method throws on access to 'arguments' property", "'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context");

            var a = new A();

            assert.isFalse(a.hasOwnProperty('caller'), "Class instance does not report that it has own property 'caller'")
            assert.isFalse(a.hasOwnProperty('arguments'), "Class instance does not report that it has own property 'arguments'")

            assert.isFalse(a.__proto__.hasOwnProperty('caller'), "Class prototype does not report that it has own property 'caller'")
            assert.isTrue(a.__proto__.hasOwnProperty('arguments'), "Class prototype has own property 'arguments'")

            a.arguments = 50;
            assert.areEqual(50, my_v, "Accessing the 'arguments' property was not restricted");

            assert.areEqual(undefined, a.caller, "Access to class instance 'caller' property doesn't throw - instance is not a function");

            a.caller = 123;

            assert.areEqual(123, a.caller, "Assignment to class instance 'caller' property works normally");
        }
    },
    {
        name: "Restricted properties of lambda",
        body: function () {
            var obj = () => { }

            verifyDoesNotHaveRestrictedOwnProperties(obj, "Lambda");
        }
    },
    {
        name: "Restricted properties of strict-mode lambda",
        body: function () {
            var obj = () => { 'use strict'; }

            verifyDoesNotHaveRestrictedOwnProperties(obj, "Strict-mode lambda");
        }
    },
    {
        name: "Restricted properties of bound function",
        body: function () {
            function target() {}
            var obj = target.bind(null);

            verifyDoesNotHaveRestrictedOwnProperties(obj, "Bound function");
        }
    },
    {
        name: "Restricted properties of bound strict-mode function",
        body: function () {
            function target() { 'use strict'; }
            var obj = target.bind(null);

            verifyDoesNotHaveRestrictedOwnProperties(obj, "Bound strict-mode function");
        }
    },
    {
        name: "Restricted properties of generator function",
        body: function () {
            function* gf() { }

            verifyDoesNotHaveRestrictedOwnProperties(gf, "Generator function");
        }
    },
    {
        name: "Restricted properties of strict-mode generator function",
        body: function () {
            function* gf() { 'use strict'; }

            verifyDoesNotHaveRestrictedOwnProperties(gf, "Generator strict-mode function");
        }
    },
    {
        name: "Restricted properties of object-literal function",
        body: function () {
            var obj = { func() { } }

            verifyHasRestrictedOwnProperties(obj.func, "Object-literal function");
        }
    },
    {
        name: "Restricted properties of strict-mode object-literal function",
        body: function () {
            var obj = { func() { 'use strict'; } }

            verifyDoesNotHaveRestrictedOwnProperties(obj.func, "Object-literal strict-mode function");
        }
    },
];

testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });