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