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

// ES6 Array extension tests -- verifies the API shape and basic functionality

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

var tests = [
    {
        name: "Array constructor has correct functions",
        body: function() {
            assert.isTrue(Array.hasOwnProperty('from'), "Array.hasOwnProperty('from');");
            assert.areEqual('function', typeof Array.from, "typeof Array.from === 'function'");
            assert.areEqual(1, Array.from.length, "Array.from.length === 0");

            assert.isTrue(Array.hasOwnProperty('of'), "Array.hasOwnProperty('of');");
            assert.areEqual('function', typeof Array.of, "typeof Array.of === 'function'");
            assert.areEqual(0, Array.of.length, "Array.of.length === 0");
        }
    },
    {
        name: "[0].indexOf(-0.0) should return 0",
        body: function() {
            assert.areEqual(0, [0].indexOf(-0.0), "[0].indexOf(-0.0) should return 0");
        }
    },
    {
        name: "Array.from basic behavior",
        body: function() {
            assert.areEqual([], Array.from([]), "Array.from simplest usage is copying empty array");

            assert.areEqual([], Array.from([], undefined), "Array.from disables mapping function when the param is explicitly passed as undefined");

            assert.areEqual([0,1,2,3], Array.from([0,1,2,3]), "Array.from basic behavior with an iterable object");
            assert.areEqual([0,1,2,3], Array.from({ 0: 0, 1: 1, 2: 2, 3: 3, length: 4 }), "Array.from basic behavior with an object with length but no iterator");
        }
    },
    {
        name: "Array.from special behaviors",
        body: function() {
            var fromFnc = Array.from;

            var b = fromFnc.call(Array, "string");
            assert.areEqual('object', typeof b, "Array.from.call(Array, 'string') returns an array");
            assert.areEqual(['s','t','r','i','n','g'], b, "Array.from.call(Array, 'string') == ['s','t','r','i','n','g']");
            assert.areEqual(6, b.length, "Array.from.call(Array, 'string').length === 6");
            assert.isFalse(ArrayBuffer.isView(b), "Array.from.call(Array, 'string') is not a TypedArray");

            var b = fromFnc.call(String, [0,1,2,3]);
            assert.areEqual('object', typeof b, "Array.from.call(String, [0,1,2,3]) returns a String object");
            assert.areEqual('', b.toString(), "Array.from.call(String, [0,1,2,3]).toString() == '4'");
            assert.areEqual(0, b.length, "Array.from.call(String, [0,1,2,3]).length === 1");
            assert.isFalse(ArrayBuffer.isView(b), "Array.from.call(String, [0,1,2,3]) is not a TypedArray");
            assert.areEqual(0, b[0], "Integer-indexed properties are still added to the string");
            assert.areEqual(1, b[1], "Integer-indexed properties are still added to the string");
            assert.areEqual(2, b[2], "Integer-indexed properties are still added to the string");
            assert.areEqual(3, b[3], "Integer-indexed properties are still added to the string");

            var a = { 0: 0, 1: 1, 2: 2, 3: 3, length: 4 };
            var b = fromFnc.call(String, a);
            assert.areEqual('object', typeof b, "Array.from.call(String, objectLikeArray) returns a String object");
            assert.areEqual('4', b.toString(), "Array.from.call(String, objectLikeArray).toString() == '4'");
            assert.areEqual(1, b.length, "Array.from.call(String, objectLikeArray).length === 1");
            assert.isFalse(ArrayBuffer.isView(b), "Array.from.call(String, objectLikeArray) is not a TypedArray");
            assert.areEqual(1, b[1], "Integer-indexed properties are still added to the string");
            assert.areEqual(2, b[2], "Integer-indexed properties are still added to the string");
            assert.areEqual(3, b[3], "Integer-indexed properties are still added to the string");
            assert.areEqual('4', b[0], "Zero-th property of the string is set to the string value, can't overwrite this via put");

            assert.throws(function() { fromFnc.call(Uint8Array, { 0: 0, 1: 1, 2: 2, length: 5 }); }, TypeError, "Array.from tries to set length of the object returned from the constructor which will throw for TypedArrays", "Cannot define property: object is not extensible");

            var a = { 0: 0, 1: 1, 3: 3, length: 5 };
            var b = fromFnc.call(Array, a);
            assert.areEqual('object', typeof b, "Array.from.call(Array, objectWithLengthProperty) returns an object");
            assert.areEqual('0,1,,3,', b.toString(), "Array.from.call(String, [0,1,2,3]).toString() == '4'");
            assert.areEqual(5, b.length, "Array.from.call(Array, objectWithLengthProperty) returns a new array with length = a.length");
            assert.isFalse(ArrayBuffer.isView(b), "Array.from.call(Array, objectWithLengthProperty) is not a TypedArray (ArrayBuffer.isView)");
            assert.areEqual([0,1,undefined,3,undefined], b, "Array.from.call(Array, objectWithLengthProperty) has missing values set to undefined");

            var a = { 0: 0, 1: 1 };
            var b = fromFnc.call(Array, a);
            assert.areEqual('object', typeof b, "Array.from.call(Array, objectWithLengthNoProperty) returns an object");
            assert.areEqual(0, b.length, "Array.from.call(Array, objectWithLengthNoProperty) returns a new array with length = 0");
            assert.isFalse(ArrayBuffer.isView(b), "Array.from.call(Array, objectWithLengthNoProperty) is not a TypedArray (ArrayBuffer.isView)");
            assert.areEqual([], b, "Array.from.call(Array, objectWithLengthNoProperty) is an empty array");

            assert.areEqual([0,1,2], fromFnc.call(undefined, [0,1,2]), "Calling Array.from with undefined this argument produces an array");
            assert.areEqual([0,1,2], fromFnc.call(null, [0,1,2]), "Calling Array.from with null this argument produces an array");
            assert.areEqual([0,1,2], fromFnc.call({}, [0,1,2]), "Calling Array.from with a non-function this argument produces an array");
            assert.areEqual([0,1,2], fromFnc.call(Math.sin, [0,1,2]), "Calling Array.from with a non-constructor function this argument produces an array");
        }
    },
    {
        name: "Array.from error conditions",
        body: function() {
            assert.throws(function () { Array.from(); }, TypeError, "Calling Array.from with non-object items argument throws TypeError", "Array.from: argument is not an Object");
            assert.throws(function () { Array.from(undefined); }, TypeError, "Calling Array.from with non-object items argument throws TypeError", "Array.from: argument is not an Object");
            assert.throws(function () { Array.from(null); }, TypeError, "Calling Array.from with non-object items argument throws TypeError", "Array.from: argument is not an Object");
            assert.throws(function () { Array.from({}, null); }, TypeError, "Calling Array.from with non-object mapFn argument throws TypeError", "Array.from: argument is not a Function object");
            assert.throws(function () { Array.from({}, 'string'); }, TypeError, "Calling Array.from with non-object mapFn argument throws TypeError", "Array.from: argument is not a Function object");
            assert.throws(function () { Array.from({}, {}); }, TypeError, "Calling Array.from with non-function mapFn argument throws TypeError", "Array.from: argument is not a Function object");
        }
    },
    {
        name: "Array.from behavior with a map function",
        body: function() {
            var i = 0;

            function mapFunction(val, k) {
                assert.areEqual(i, k, "Array.from called with a mapping function, we should get the elements in order. Setting item[" + k + "] = " + val);
                assert.areEqual(val, k, "Array.from called with a mapping function, Value and index should be same for this test");
                assert.areEqual(2, arguments.length, "Array.from called with a mapping function, only 2 elements should be passed as arguments");
                // increment expected index
                i++;
            }

            var objectWithoutIterator = {
                0: 0,
                1: 1,
                2: 2,
                3: 3,
                length: 4
            };

            // Verify mapFunction gets called with correct arguments
            Array.from(objectWithoutIterator, mapFunction);
        }
    },
    {
        name: "Array.from behavior with a map function passing this argument",
        body: function() {
            var thisArg = 'thisArg';

            function mapFunction(val, k) {
                // this will be wrapped as an Object
                assert.areEqual(Object(thisArg), this, "thisArg passed into Array.from should flow into mapFunction");
            }

            var objectWithoutIterator = {
                0: 0,
                1: 1,
                2: 2,
                3: 3,
                length: 4
            };

            // Verify mapFunction gets called with thisArg passed as this
            Array.from(objectWithoutIterator, mapFunction, thisArg);
        }
    },
    {
        name: "Array.from behavior with a map function that mutates source object",
        body: function() {
            var objectWithoutIterator = {
                0: 0,
                1: 1,
                2: 2,
                3: 3,
                4: 4,
                length: 5
            };

            function mapFunction(val, k) {
                switch (k) {
                    case 0:
                        // change the objectWithoutIterator length value - we should still fetch the rest of the indexed-elements anyway
                        objectWithoutIterator.length = 0;
                        return val;
                    case 1:
                        // change the value of the next indexed value - the new value should end up in the return object
                        objectWithoutIterator[2] = 200;
                        return val;
                    case 2:
                        // change the value of a previous indexed value - the old value should end up in the return object
                        objectWithoutIterator[0] = -100;
                        return val;
                    case 3:
                        // delete the next indexed value - return object should have undefined there
                        delete objectWithoutIterator[4];
                        return val;
                }

                // otherwise
                return val;
            }

            assert.areEqual([0,1,200,3,undefined], Array.from(objectWithoutIterator, mapFunction), "Array.from called with a map function that mutates the source object");
        }
    },
    {
        name: "Array.from behavior with iterator and a map function",
        body: function() {
            var j = 0;
            var checkThisArg = false;
            var thisArg = 'string';

            var objectWithIterator = {
                [Symbol.iterator]: function() {
                    return {
                        i: 0,
                        next: function () {
                            return {
                                done: this.i == 5,
                                value: this.i++
                            };
                        }
                    };
                }
            };

            function mapFunction(val, k) {
                assert.areEqual(j, val, "Array.from called with a mapping function, we should get the elements in order. Setting item[" + j + "] = " + val);
                assert.areEqual(val, k, "Array.from called with a mapping function, index should match the value passed in");
                assert.areEqual(2, arguments.length, "Array.from called with a mapping function, only 2 elements should be passed as arguments");

                // increment expected value
                j++;

                if (checkThisArg) {
                    // this will be wrapped as an Object
                    assert.areEqual(Object(thisArg), this, "thisArg passed into Array.from should flow into mapFunction");
                }
            }

            // Verify mapFunction gets called with correct arguments
            Array.from(objectWithIterator, mapFunction);

            j = 0;
            checkThisArg = true;

            // Verify mapFunction gets called with thisArg passed as this
            Array.from(objectWithIterator, mapFunction, thisArg);
        }
    },
    {
        name: "Array.from behavior with iterator and a map function which mutates the iterator state",
        body: function() {
            var iterator_val = 0;

            var objectWithIterator = {
                [Symbol.iterator]: function() {
                    return {
                        next: function () {
                            return {
                                done: iterator_val == 5,
                                value: iterator_val++
                            };
                        }
                    };
                }
            };

            var reset = false;
            function mapFunction(val, k) {
                if (val == 2 && !reset)
                {
                    reset = true;
                    iterator_val = 0;
                }

                return val;
            }

            assert.areEqual([0,1,2,0,1,2,3,4], Array.from(objectWithIterator, mapFunction), "Array.from called with map function which alters iterator state");
        }
    },
    {
        name: "Array.from behavior with badly formed iterator objects",
        body: function() {
            var objectWithIteratorThatIsNotAFunction = { [Symbol.iterator]: 'a string' };
            var objectWithIteratorWhichDoesNotReturnObjects = { [Symbol.iterator]: function() { return undefined; } };
            var objectWithIteratorNextIsNotAFunction = { [Symbol.iterator]: function() { return { next: undefined }; } };
            var objectWithIteratorNextDoesNotReturnObjects = { [Symbol.iterator]: function() { return { next: function() { return undefined; } }; } };

            assert.throws(function() { Array.from(objectWithIteratorThatIsNotAFunction); }, TypeError, "obj[@@iterator] must be a function", "Function expected");
            assert.throws(function() { Array.from(objectWithIteratorWhichDoesNotReturnObjects); }, TypeError, "obj[@@iterator] must return an object", "Object expected");
            assert.throws(function() { Array.from(objectWithIteratorNextIsNotAFunction); }, TypeError, "obj[@@iterator].next must be a function", "Function expected");
            assert.throws(function() { Array.from(objectWithIteratorNextDoesNotReturnObjects); }, TypeError, "obj[@@iterator].next must return an object", "Object expected");

            var objectWithUndefinedIterator = { 0: "a", 1: "b", length: 2, [Symbol.iterator]: undefined };
            var objectWithNullIterator = { 0: "a", 1: "b", length: 2, [Symbol.iterator]: null };

            assert.areEqual([ "a", "b" ], Array.from(objectWithUndefinedIterator), "'@@iterator: undefined' is ignored");
            assert.areEqual([ "a", "b" ], Array.from(objectWithNullIterator), "'@@iterator: null' is ignored");
        }
    },
    {
        name: "Array.of basic behavior",
        body: function() {
            assert.areEqual([], Array.of(), "Array.of basic behavior with no arguments");
            assert.areEqual([3], Array.of(3), "Array.of basic behavior with a single argument");
            assert.areEqual([0,1,2,3], Array.of(0, 1, 2, 3), "Array.of basic behavior with a list of arguments");
        }
    },
    {
        name: "Array.of extended behavior",
        body: function() {
            var ofFnc = Array.of;

            assert.throws(function() { ofFnc.call(Uint8ClampedArray, 0, -1, 2, 300, 4); }, TypeError, "Array.of tries to set length of the object returned from the constructor which will throw for TypedArrays", "Cannot define property: object is not extensible");

            var b = ofFnc.call(Array, 'string', 'other string', 5, { 0: 'string val',length:10 });
            assert.areEqual('object', typeof b, "Array.of.call(Array, ...someStringsAndObjects) returns an array");
            assert.areEqual(['string','other string',5,{ 0: 'string val',length:10 }], b, "Array.of.call(Array, ...someStringsAndObjects) == ['string','other string',5,{ 0: 'string val',length:10 }]");
            assert.areEqual(4, b.length, "Array.of.call(Array, ...someStringsAndObjects).length === 4");
            assert.isFalse(ArrayBuffer.isView(b), "Array.of.call(Array, ...someStringsAndObjects) is not a TypedArray");

            var b = ofFnc.call(String, 0, 1, 2, 3);
            assert.areEqual('object', typeof b, "Array.of.call(String, 0, 1, 2, 3) returns a string object");
            assert.areEqual(1, b.length, "Array.of.call(String, 0, 1, 2, 3) returns a string object with length 1");
            assert.areEqual('4', b.toString(), "Array.of.call(String, 0, 1, 2, 3) returns a string object with value == '4'");
            assert.areEqual('4', b[0], "Array.of.call(String, 0, 1, 2, 3) returns a string object s. s[0] == '4'");
            assert.areEqual(1, b[1], "Array.of.call(String, 0, 1, 2, 3) returns a string object s. s[1] == 1");
            assert.areEqual(2, b[2], "Array.of.call(String, 0, 1, 2, 3) returns a string object s. s[2] == 2");
            assert.areEqual(3, b[3], "Array.of.call(String, 0, 1, 2, 3) returns a string object s. s[3] == 3");

            assert.areEqual([], ofFnc.call(Array), "Array.of.call(Array) returns empty array");
            assert.areEqual([], ofFnc.call(), "Array.of.call() returns empty array");
            assert.areEqual(new String(0), ofFnc.call(String), "Array.of.call(String) returns empty string");
            assert.areEqual("0", ofFnc.call(String).toString(), "Array.of.call(String) returns empty string");
        }
    },
    {
        name: "OS:840217 - Array.from, Array#fill, Array#lastIndexOf should use ToLength instead of ToUint32 on their parameter's length property",
        body: function() {
            // ToLength(-1) should be 0 which means we won't execute any iterations in the below calls.
            Array.from({length: -1});
            Array.prototype.fill.call({length: -1}, 'a');
            Array.prototype.lastIndexOf.call({length: -1}, 'a');
        }
    },
    {
        name: "Array.from called with an items object that has length > 2^32-1 and is not iterable",
        body: function() {
            var o = {length: 4294967301};

            assert.throws(function() { Array.from(o); }, RangeError, "Array.from uses abstract operation ArrayCreate which throws RangeError when requested length > 2^32-1", "Array length must be a finite positive integer");
        }
    },
    {
        name: "Array.from doesn't get @@iterator twice",
        body: function () {
            let count = 0;
            Array.from({
                get [Symbol.iterator]() {
                    count++;
                    return [][Symbol.iterator];
                }
            });
            assert.areEqual(count, 1, "Array.from calls @@iterator getter once");

            count = 0;
            Array.from(new Proxy({}, {
                get(target, property) {
                    if (property === Symbol.iterator) {
                        count++;
                        return [][Symbol.iterator];
                    }
                    return Reflect.get(target, property);
                }
            }));
            assert.areEqual(count, 1, "Array.from calls proxy's getter with @@iterator as parameter only once");
        }
    },
    {
        name: "Array#fill called with an object that has length > 2^32-1",
        body: function() {
            var e = {length: 4294967301, 4294967297: 1234};
            Array.prototype.fill.call(e, 5678, 4294967298, 4294967300);

            assert.areEqual(1234, e[4294967297], "Array.prototype.fill called on an object with length > 2^32 and a fill range existing completely past 2^32 does not fill elements outside the request range");
            assert.areEqual(5678, e[4294967298], "Array.prototype.fill called on an object with length > 2^32 and a fill range existing completely past 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(5678, e[4294967299], "Array.prototype.fill called on an object with length > 2^32 and a fill range existing completely past 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(undefined, e[4294967300], "Array.prototype.fill called on an object with length > 2^32 and a fill range existing completely past 2^32 does not fill elements outside the request range");

            var e = {length: 4294967301, 4294967292: 1234};
            Array.prototype.fill.call(e, 5678, 4294967293, 4294967300);

            assert.areEqual(1234, e[4294967292], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 does not fill elements outside the request range");
            assert.areEqual(5678, e[4294967293], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(5678, e[4294967294], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(5678, e[4294967295], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(5678, e[4294967299], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 is able to fill elements with indices > 2^32");
            assert.areEqual(undefined, e[4294967300], "Array.prototype.fill called on an object with length > 2^32 and a fill range starting before 2^32 but ending after 2^32 does not fill elements outside the request range");
        }
    },
    {
        name: "Array#lastIndexOf called with an object that has length > 2^32-1",
        body: function() {
            var e = {length: 4294967301, 4294967291: 1234, 4294967294: 5678, 4294967295: 5678, 4294967296: 5678, 4294967297: 9};

            assert.areEqual(4294967291, Array.prototype.lastIndexOf.call(e, 1234, 4294967300), "Array.prototype.lastIndexOf called on an object with length > 2^32 and a fromIndex also > 2^32 finds the element when expected index is < 2^32");
            assert.areEqual(4294967296, Array.prototype.lastIndexOf.call(e, 5678, 4294967300), "Array.prototype.lastIndexOf called on an object with length > 2^32 and a fromIndex also > 2^32 finds the element when expected index is > 2^32");

            var e = [1,2,3,4];

            assert.areEqual(0, Array.prototype.lastIndexOf.call(e, 1, 4294967296), "Array.prototype.lastIndexOf is able to find the element when it exists at index 0 when fromIndex > 2^32");
            assert.areEqual(0, Array.prototype.lastIndexOf.call(e, 1), "Array.prototype.lastIndexOf is able to find the element when it exists at index 0 when fromIndex not defined");
        }
    },
    {
        name: "Array#copyWithin called with an object that has length > 2^32-1 and parameters also > 2^32-1",
        body: function() {
            var e = {length: 4294967301, 4294967292: 4294967292, 4294967293: 4294967293, 4294967294: 4294967294};
            Array.prototype.copyWithin.call(e, 5, 4294967292, 4294967294);

            assert.areEqual(4294967292, e[5], "Array.prototype.copyWithin called on an object with length > 2^32 and a source and destination range completely < 2^32");
            assert.areEqual(4294967293, e[6], "Array.prototype.copyWithin called on an object with length > 2^32 and a source and destination range completely < 2^32");

            var e = {length: 4294967304, 4294967300: 4294967300, 4294967301: 4294967301, 4294967302: 4294967302, 4294967303: 4294967303};
            Array.prototype.copyWithin.call(e, 4294967297, 4294967300, 4294967303);

            assert.areEqual(4294967300, e[4294967297], "Array.prototype.copyWithin called on an object with length > 2^32 and a source and destination range completely > 2^32");
            assert.areEqual(4294967301, e[4294967298], "Array.prototype.copyWithin called on an object with length > 2^32 and a source and destination range completely > 2^32");
            assert.areEqual(4294967302, e[4294967299], "Array.prototype.copyWithin called on an object with length > 2^32 and a source and destination range completely > 2^32");

            var e = {length: 4294967301, 4294967297: 4294967297, 4294967298: 4294967298, 4294967299: 4294967299};
            Array.prototype.copyWithin.call(e, 5, 4294967297, 4294967300);

            assert.areEqual(4294967297, e[5], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967298, e[6], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967299, e[7], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range completely < 2^32");

            var e = {length: 4294967301, 0: 0, 1: 1, 2: 2, 3: 3, 4: 4};
            Array.prototype.copyWithin.call(e, 4294967297, 0, 5);

            assert.areEqual(0, e[4294967297], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range completely > 2^32");
            assert.areEqual(1, e[4294967298], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range completely > 2^32");
            assert.areEqual(2, e[4294967299], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range completely > 2^32");
            assert.areEqual(3, e[4294967300], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range completely > 2^32");

            var e = {length: 4294967301, 4294967292: 4294967292, 4294967293: 4294967293, 4294967294: 4294967294, 4294967295: 4294967295, 4294967296: 4294967296, 4294967297: 4294967297, 4294967298: 4294967298, 4294967299: 4294967299, 4294967300: 4294967300};
            Array.prototype.copyWithin.call(e, 5, 4294967292, 4294967301);

            assert.areEqual(4294967292, e[5], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967293, e[6], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967294, e[7], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967295, e[8], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967296, e[9], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967297, e[10], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967298, e[11], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967299, e[12], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");
            assert.areEqual(4294967300, e[13], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely < 2^32");

            var e = {length: 4294967400, 4294967292: 4294967292, 4294967293: 4294967293, 4294967294: 4294967294, 4294967295: 4294967295, 4294967296: 4294967296, 4294967297: 4294967297, 4294967298: 4294967298, 4294967299: 4294967299, 4294967300: 4294967300};
            Array.prototype.copyWithin.call(e, 4294967350, 4294967292, 4294967301);

            assert.areEqual(4294967292, e[4294967350], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967293, e[4294967351], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967294, e[4294967352], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967295, e[4294967353], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967296, e[4294967354], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967297, e[4294967355], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967298, e[4294967356], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967299, e[4294967357], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");
            assert.areEqual(4294967300, e[4294967358], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range crossing 2^32 and destination range completely > 2^32");

            var e = {length: 4294967301, 0: 0, 1: 1, 2: 2, 3: 3, 4: 4};
            Array.prototype.copyWithin.call(e, 4294967293, 0, 5);

            assert.areEqual(0, e[4294967293], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range crossing 2^32");
            assert.areEqual(1, e[4294967294], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range crossing 2^32");
            assert.areEqual(2, e[4294967295], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range crossing 2^32");
            assert.areEqual(3, e[4294967296], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range crossing 2^32");
            assert.areEqual(4, e[4294967297], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely < 2^32 and destination range crossing 2^32");

            var e = {length: 4294967420, 4294967400: 4294967400, 4294967401: 4294967401, 4294967402: 4294967402, 4294967403: 4294967403, 4294967404: 4294967404};
            Array.prototype.copyWithin.call(e, 4294967293, 4294967400, 4294967405);

            assert.areEqual(4294967400, e[4294967293], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range crossing 2^32");
            assert.areEqual(4294967401, e[4294967294], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range crossing 2^32");
            assert.areEqual(4294967402, e[4294967295], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range crossing 2^32");
            assert.areEqual(4294967403, e[4294967296], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range crossing 2^32");
            assert.areEqual(4294967404, e[4294967297], "Array.prototype.copyWithin called on an object with length > 2^32 and a source range completely > 2^32 and destination range crossing 2^32");
        }
    },
    {
        name: "Array#lastIndexOf called with a fromIndex < 0 && abs(fromIndex) > length (OS #1185913)",
        body: function() {
            var a = [0, 1];
            var r = a.lastIndexOf(0, -3);

            assert.areEqual(-1, r, "Array.prototype.lastIndexOf returns -1 when the search element is not found");
        }
    },
    {
        name: "Array.of() called with the a bound function without a constructor should not throw an exception",
        body: function () {
            var val = Math.cos.bind(Math);
            assert.isTrue(Array.isArray(Array.of.call(val)));
        }
    },
    {
        name: "Array.of() should not invoke setter",
        body: function () {
            function Bag() {}
            Bag.of = Array.of;
            Object.defineProperty(Bag.prototype, "0", {set: function(v) { /* no-op */ }});
            assert.areEqual(1, Bag.of(1)[0]);
        }
    },
    {
        name: "Array.from() should not invoke setter in iterable case",
        body: function () {
            function Bag() {}
            Bag.from = Array.from;
            Object.defineProperty(Bag.prototype, "0", {set: function(v) { throw "Fail"; }});
            var a = [1,2,3];
            assert.areEqual(1, Bag.from(a)[0]);
        }
    },
    {
        name: "Array.from() should not invoke setter in array like case",
        body: function () {
            function Bag() {}
            Bag.from = Array.from;
            Object.defineProperty(Bag.prototype, "0", {set: function(v) { throw "Fail"; }});
            var a = {};
            a[0] = 1;
            a[1] = 2;
            a[2] = 3;
            a.length = 3;
            assert.areEqual(1, Bag.from(a)[0]);
        }
    },
    {
        name: "Array.filter() should not invoke setter even with substituted constructor",
        body: function () {
            var a = [1,2,3];
            a.constructor = function()
            {
                function Bag() {};
                Object.defineProperty(Bag.prototype, "0", { set: function(v){ throw "Fail"; } });
                return new Bag();
            };
            assert.areEqual(1, a.filter(function(v){return v % 2 == 1;})[0]);
        }
    },
    {
        name: "Array.map() should not invoke setter even with substituted constructor",
        body: function () {
            var a = [1,2,3];
            a.constructor = function()
            {
                function Bag() {};
                Object.defineProperty(Bag.prototype, "0", { set: function(v){ throw "Fail"; } });
                return new Bag();
            };
            assert.areEqual(1, a.map(function(v){return v % 2;})[0]);
        }
    },
    {
        name: "Array.slice() should not invoke setter even with substituted constructor",
        body: function () {
            var a = [1,2,3];
            a.constructor = function()
            {
                function Bag() {};
                Object.defineProperty(Bag.prototype, "0", { set: function(v){ throw "Fail"; } });
                return new Bag();
            };
            assert.areEqual(2, a.slice(1, 3)[0]);
        }
    },
    {
        name: "Array.splice() should not invoke setter even with substituted constructor",
        body: function () {
            var a = [1,2,3];
            a.constructor = function()
            {
                function Bag() {};
                Object.defineProperty(Bag.prototype, "0", { set: function(v){ throw "Fail"; } });
                return new Bag();
            };
            assert.areEqual(1, a.splice(0, 1, 'x')[0]);
        }
    },
    {
        name: "Array.fill() should throw when applied on frozen array",
        body: function () {
            var x = [0];
            Object.freeze(x);
            assert.throws(function() { Array.prototype.fill.call(x) }, TypeError, "We should get a TypeError when fill is applied to a frozen array");
        }
    },
    {
        name: "Array.copyWithin() should throw when applied on frozen array",
        body: function () {
            var x = [1,2,3,4,5];
            Object.freeze(x);
            assert.throws(function() { Array.prototype.fill.copyWithin(x, 1, 2) }, TypeError, "We should get a TypeError when fill is applied to a frozen array");
        }
    },
    {
        name: "Array.concat() should always box the first item",
        body: function () {
            assert.isTrue(typeof Array.prototype.concat.call(101)[0] === "object");
        }
    },
    {
        name: "Boolean primitive should never be considered concat spreadable",
        body: function () {
            try
            {
                Boolean.prototype[Symbol.isConcatSpreadable] = true;
                Boolean.prototype[0] = 1;
                Boolean.prototype[1] = 2;
                Boolean.prototype[2] = 3;
                Boolean.prototype.length = 3;
                assert.isTrue([].concat(true).length === 1); /** True is added to the array as an literal, not spreaded */
            }
            finally
            {
                delete Boolean.prototype[Symbol.isConcatSpreadable];
                delete Boolean.prototype[0];
                delete Boolean.prototype[1];
                delete Boolean.prototype[2];
                delete Boolean.prototype.length;
            }
        }
    },
    {
        name: "String primitive should never be considered concat spreadable",
        body: function () {
            try
            {
                String.prototype[Symbol.isConcatSpreadable] = true;
                String.prototype[0] = 1;
                String.prototype[1] = 2;
                String.prototype[2] = 3;
                String.prototype.length = 3;
                assert.isTrue([].concat("Hello").length === 1); /** True is added to the array as an literal, not spreaded */
            }
            finally
            {
                delete String.prototype[Symbol.isConcatSpreadable];
                delete String.prototype[0];
                delete String.prototype[1];
                delete String.prototype[2];
                delete String.prototype.length;
            }
        }
    }
];

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