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

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

var tests = [
    {
        name: "Object.values/entries should exist and constructed properly",
        body: function () {
            assert.isTrue(Object.hasOwnProperty('values'), "Object should have a values method");
            assert.isTrue(Object.hasOwnProperty('entries'), "Object should have a entries method");
            assert.areEqual(1, Object.values.length, "values method takes one argument");
            assert.areEqual(1, Object.entries.length, "entries method takes one argument");
            assert.areEqual("values", Object.values.name, "values.name is 'values'");
            assert.areEqual("entries", Object.entries.name, "entries.name is 'entries'");
            
            var descriptor = Object.getOwnPropertyDescriptor(Object, 'values');
            assert.isTrue(descriptor.writable, "writable(values) must be true");
            assert.isFalse(descriptor.enumerable, "enumerable(values) must be false");
            assert.isTrue(descriptor.configurable, "configurable(values) must be true");
            
            descriptor = Object.getOwnPropertyDescriptor(Object, 'entries');
            assert.isTrue(descriptor.writable, "writable(entries) must be true");
            assert.isFalse(descriptor.enumerable, "enumerable(entries) must be false");
            assert.isTrue(descriptor.configurable, "configurable(entries) must be true");
        }
    },
    {
        name: "Object.values/entries basic syntax",
        body: function () {
            assert.throws(function () { eval("Object.values();"); }, TypeError, "Calling values method without any arguments throws an error", "Object expected");
            assert.throws(function () { eval("Object.values(undefined);"); }, TypeError, "Calling values method on undefined throws an error", "Object expected");
            assert.throws(function () { eval("Object.values(null);"); }, TypeError, "Calling values method on null throws an error", "Object expected");
            assert.isTrue(Array.isArray(Object.values({})), "calling values method on an object returns an array");
            assert.areEqual(0, Object.values({}).length, "calling values method on an empty object returns an empty array");

            assert.throws(function () { eval("Object.entries();"); }, TypeError, "Calling entries method without any arguments throws an error", "Object expected");
            assert.throws(function () { eval("Object.entries(undefined);"); }, TypeError, "Calling entries method on undefined throws an error", "Object expected");
            assert.throws(function () { eval("Object.entries(null);"); }, TypeError, "Calling entries method on null throws an error", "Object expected");
            assert.isTrue(Array.isArray(Object.entries({})), "calling entries method on an object returns an array");
            assert.areEqual(0, Object.entries({}).length, "calling entries method on an empty object returns an empty array");
        }
    },
    {
        name: "Object.values/entries functionality",
        body: function () {
            var a1 = {prop1:10, prop2:20};
            var values = Object.values(a1);
            assert.areEqual(2, values.length, "calling values on an object with two properties will returned an array of 2 elements");
            assert.areEqual(10, values[0], "First element of the returned values array should be 10");
            assert.areEqual(20, values[1], "Second element of the returned values array should be 20");

            var entries = Object.entries(a1);
            assert.areEqual(2, entries.length, "calling entries on an object with two properties will returned an array of 2 elements");
            assert.isTrue(Array.isArray(entries[0]) && Array.isArray(entries[1]), "each element itself an array of key, value pair");
            assert.areEqual(["prop1", 10], entries[0], "First element of the returned entry array should be ['prop1', 10]");
            assert.areEqual(["prop2", 20], entries[1], "Second element of the returned entry array should be ['prop2', 20]");
            
            var a2 = {prop3 : 30};
            a2[2] = 40;
            a2["prop4"] = 50;
            Object.defineProperty(a2, "prop5", { value: 60, enumerable: true});
            Object.defineProperty(a2, "prop6", { value: 70, enumerable: false});
            Object.defineProperty(a2, 'prop7', {  enumerable: true, get: function () { return 80;}});
            var sym = Symbol('prop8');
            a2[sym] = 90;

            values = Object.values(a2);
            assert.areEqual(5, values.length, "values method returns an array of 5 elements, symbol and non-enumerable should be excluded");
            assert.areEqual([40,30,50,60,80], values, "values method returns an array and matches correctly");
            
            entries = Object.entries(a2);
            assert.areEqual(5, entries.length, "entries method returns an array of 5 elements, symbol and non-enumerable should be excluded");
            assert.areEqual("2,40,prop3,30,prop4,50,prop5,60,prop7,80", entries.toString(), "entries method returns an array and matches correctly");
        }
    },
    {
        name: "Object.values/entries with proxy",
        body: function () {
            var obj1 = {prop1:10};
            var proxy1 = new Proxy(obj1, { });
            var values = Object.values(proxy1);
            assert.areEqual(1, values.length, "values - Proxy object on an object with one property returns an array of 1 element");
            assert.areEqual(10, values[0], "values - Proxy object on an object with one property returns correct element");

            var entries = Object.entries(proxy1);
            assert.areEqual(1, entries.length, "entries - Proxy object on an object with one property returns an array of 1 element");
            assert.areEqual(["prop1", 10], entries[0], "entries - Proxy object on an object with one property returns correct element");

            var obj2 = {};
            Object.defineProperty(obj2, "prop2", { value: 20, enumerable: true });
            Object.defineProperty(obj2, "prop3", { get: function () { return 30; }, enumerable: true });
            var proxy2 = new Proxy(obj2, {
                getOwnPropertyDescriptor: function (target, property) {
                    return Reflect.getOwnPropertyDescriptor(target, property);
                }
            });
            
            values = Object.values(proxy2);
            assert.areEqual(2, values.length, "values - exhibiting a Proxy trapping getOwnPropertyDescriptor returns an aray to 2 elements");
            assert.areEqual(20, values[0], "values - a Proxy trapping getOwnPropertyDescriptor matching the first element");
            assert.areEqual(30, values[1], "values - a Proxy trapping getOwnPropertyDescriptor matching the second element");

            entries = Object.entries(proxy2);
            assert.areEqual(2, entries.length, "values - exhibiting a Proxy trapping getOwnPropertyDescriptor returns an aray to 2 elements");
            assert.areEqual(["prop2", 20], entries[0], "entries - a Proxy trapping getOwnPropertyDescriptor matching the first element");
            assert.areEqual(["prop3", 30], entries[1], "entries - a Proxy trapping getOwnPropertyDescriptor matching the second element");

            var obj3 = {};
            var count = 0;
            var proxy3 = new Proxy(obj3, {
                get: function (target, property, receiver) {
                    return count++ * 5;
                },
                getOwnPropertyDescriptor: function (target, property) {
                    return {configurable: true, enumerable: true};
                },

                ownKeys: function (target) {
                    return ["prop0", "prop1", Symbol("prop2"), Symbol("prop5")];
                }
            });

            values = Object.values(proxy3);
            assert.areEqual(2, values.length, "values - exhibiting a Proxy with get and ownKeys traps - returns 2 elements");
            assert.areEqual(0, values[0], "values - exhibiting a Proxy with get and ownKeys traps - matching first element");
            assert.areEqual(5, values[1], "values - exhibiting a Proxy with get and ownKeys traps -  matching second element");

            entries = Object.entries(proxy3);
            assert.areEqual(2, entries.length, "entries - exhibiting a Proxy with get and ownKeys trap - returns 2 elements");
            assert.areEqual(["prop0", 10], entries[0], "entries - exhibiting a Proxy with get and ownKeys trap - matching first element");
            assert.areEqual(["prop1", 15], entries[1], "entries - exhibiting a Proxy with get and ownKeys trap - matching second element");

        }
    },
    {
        name: "Object.values - deleting or making non-enumerable during enumeration",
        body: function () {
            var aDeletesB = {
                get a() {
                    delete this.b;
                    return 1;
                },
                b: 2
            };
            
            var values = Object.values(aDeletesB);
            assert.areEqual(1, values.length, "deleting next key during enumeration is excluded in the result");
            assert.areEqual(1, values[0], "deleting next key - first element is 1");
            
            var aRemovesB = {
                get a() {
                    Object.defineProperty(this, 'b', {
                        enumerable: false
                    });
                    return 1;
                },
                b: 2
            };

            values = Object.values(aRemovesB);
            assert.areEqual(1, values.length, "making the next key non-enumerable is excluded in the result");
            assert.areEqual(1, values[0], "making next nonenumerable - first element is 1");
        }
    },
    {
        name: "Object.entries - deleting or making non-enumerable during enumeration",
        body: function () {
            var aDeletesB = {
                get a() {
                    delete this.b;
                    return 1;
                },
                b: 2
            };

            var entries = Object.entries(aDeletesB);
            assert.areEqual(1, entries.length, "deleting next key during enumeration is excluded in the result");
            assert.areEqual(['a', 1], entries[0], "deleting next key - first element is 1");
            
            var aRemovesB = {
                get a() {
                    Object.defineProperty(this, 'b', {
                        enumerable: false
                    });
                    return 1;
                },
                b: 2
            };

            entries = Object.entries(aRemovesB);
            assert.areEqual(1, entries.length, "making the next key non-enumerable is excluded in the result");
            assert.areEqual(['a', 1], entries[0], "making next nonenumerable - first element is 1");
        }
    },
    {
        name: "Object.values - making non-enumerable to enumerable during enumeration",
        body: function () {
            var aAddsB = {};
            Object.defineProperty(aAddsB, "a", { get: function () { Object.defineProperty(this, 'b', { enumerable: true }); return 1; }, enumerable: true });
            Object.defineProperty(aAddsB, "b", { value: 2, configurable:true, enumerable: false});
            
            var values = Object.values(aAddsB);
            assert.areEqual(2, values.length, "making the second non-enumerable key to enumerable is included in the result");
            assert.areEqual(1, values[0], "non-enumerable to enumerable - first element is 1");
            assert.areEqual(2, values[1], "non-enumerable to enumerable - second element is 2");
        }
    },
    {
        name: "Object.entries - making non-enumerable to enumerable during enumeration",
        body: function () {
            var aAddsB = {};
            Object.defineProperty(aAddsB, "a", { get: function () { Object.defineProperty(this, 'b', { enumerable:true }); return 1; }, enumerable: true });
            Object.defineProperty(aAddsB, "b", { value: 2, configurable:true, enumerable: false});
            
            var entries = Object.entries(aAddsB);
            assert.areEqual(2, entries.length, "making the second non-enumerable key to enumerable is included in the result");
            assert.areEqual(['a', 1], entries[0], "non-enumerable to enumerable - first element is 1");
            assert.areEqual(['b', 2], entries[1], "non-enumerable to enumerable - second element is 2");
        }
    }
];

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