| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| |
| // ES6 TypedArray extension tests -- verifies the API shape and basic functionality |
| |
| WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js"); |
| |
| var tests = [ |
| { |
| name: "Uint8ClampedArray constructor exists", |
| body: function () { |
| assert.isTrue(typeof Uint8ClampedArray === 'function', "Uint8ClampedArray constructor exists"); |
| } |
| }, |
| { |
| name: "%TypedArray% intrinsic has correct properties", |
| body: function() { |
| function verifyTypedArrayConstructorPropertyValue(constructor, name, type, configurableIsTrue) { |
| var descriptor = Object.getOwnPropertyDescriptor(constructor, name); |
| var propName = constructor.name + "." + name; |
| |
| assert.isFalse(descriptor.writable, propName + ".writable === false"); |
| assert.isFalse(descriptor.enumerable, propName + ".enumerable === false"); |
| assert.areEqual(configurableIsTrue, descriptor.configurable, propName + ".configurable === " +configurableIsTrue); |
| assert.areEqual(type, typeof descriptor.value, "typeof " + propName + " === '" + type + "'"); |
| } |
| |
| var typedArrayConstructor = Int8Array.__proto__; |
| |
| assert.areEqual('function', typeof typedArrayConstructor, "typeof %TypedArray% === 'function'"); |
| |
| assert.areEqual('TypedArray', typedArrayConstructor.name, "%TypedArray%.name === 'TypedArray'"); |
| assert.areEqual(3, typedArrayConstructor.length, "%TypedArray%.length === 3"); |
| |
| assert.isTrue(typedArrayConstructor === Uint8Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Uint8ClampedArray.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Int16Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Uint16Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Int32Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Uint32Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Float32Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| assert.isTrue(typedArrayConstructor === Float64Array.__proto__, "All TypedArray constructors have their [[prototype]] slot set to the %TypedArray% intrinsic"); |
| |
| verifyTypedArrayConstructorPropertyValue(typedArrayConstructor, 'length', 'number',false); |
| verifyTypedArrayConstructorPropertyValue(typedArrayConstructor, 'name', 'string',true); |
| |
| assert.isFalse(typedArrayConstructor.from === undefined, "%TypedArray%.from !== undefined"); |
| assert.areEqual('function', typeof typedArrayConstructor.from, "typeof %TypedArray%.from == 'function'"); |
| assert.areEqual(1, typedArrayConstructor.from.length, "%TypedArray%.from.length == 1"); |
| |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayConstructor, 'from'); |
| |
| assert.isTrue(descriptor.writable, "%TypedArray%.from.writable === true"); |
| assert.isFalse(descriptor.enumerable, "%TypedArray%.from.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "%TypedArray%.from.configurable === true"); |
| |
| assert.isFalse(typedArrayConstructor.of === undefined, "%TypedArray%.of !== undefined"); |
| assert.areEqual('function', typeof typedArrayConstructor.of, "typeof %TypedArray%.of == 'function'"); |
| assert.areEqual(0, typedArrayConstructor.of.length, "%TypedArray%.of.length == 0"); |
| |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayConstructor, 'of'); |
| |
| assert.isTrue(descriptor.writable, "%TypedArray%.of.writable === true"); |
| assert.isFalse(descriptor.enumerable, "%TypedArray%.of.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "%TypedArray%.of.configurable === true"); |
| |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype% intrinsic has correct properties", |
| body: function () { |
| function verifyTypedArrayPrototypePropertyAccessor(obj, name, displayName, functionName) { |
| functionName = functionName || name; |
| var descriptor = Object.getOwnPropertyDescriptor(obj, name); |
| assert.isFalse(descriptor.enumerable, displayName + ".enumerable === false"); |
| assert.isTrue(descriptor.configurable, displayName + ".configurable === true"); |
| assert.areEqual('function', typeof descriptor.get, "typeof " + displayName + ".get === 'function'"); |
| assert.areEqual(undefined, descriptor.set, displayName + ".set === undefined"); |
| assert.areEqual(0, descriptor.get.length, displayName + ".get.length === 0"); |
| |
| var actualName = descriptor.get.toString(); |
| assert.areEqual(functionName, actualName, displayName + ".get.name = " + functionName); |
| } |
| function verifyTypedArrayPrototypePropertyFunction(obj, name, len, displayName) { |
| var descriptor = Object.getOwnPropertyDescriptor(obj, name); |
| assert.isTrue(descriptor.writable, displayName + ".writable === true"); |
| assert.isFalse(descriptor.enumerable, displayName + ".enumerable === false"); |
| assert.isTrue(descriptor.configurable, displayName + ".configurable === true"); |
| assert.areEqual('function', typeof descriptor.value, "typeof " + displayName + " === 'function'"); |
| assert.areEqual(len, descriptor.value.length, displayName + ".length === " + len); |
| } |
| |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| |
| assert.areEqual('object', typeof typedArrayPrototype, "typeof %TypedArrayPrototype% === 'object'"); |
| assert.areEqual(Int8Array.__proto__, typedArrayPrototype.constructor, "%TypedArrayPrototype%.constructor === %TypedArray%"); |
| |
| assert.isTrue(typedArrayPrototype === Uint8Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Uint8ClampedArray.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Int16Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Uint16Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Int32Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Uint32Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Float32Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| assert.isTrue(typedArrayPrototype === Float64Array.prototype.__proto__, "All TypedArray prototypes have their [[prototype]] slot set to the %TypedArrayPrototype% intrinsic"); |
| |
| verifyTypedArrayPrototypePropertyAccessor(typedArrayPrototype, "buffer", "%TypedArrayPrototype%.buffer", "get buffer"); |
| verifyTypedArrayPrototypePropertyAccessor(typedArrayPrototype, "byteLength", "%TypedArrayPrototype%.byteLength", "get byteLength"); |
| verifyTypedArrayPrototypePropertyAccessor(typedArrayPrototype, "byteOffset", "%TypedArrayPrototype%.byteOffset", "get byteOffset"); |
| verifyTypedArrayPrototypePropertyAccessor(typedArrayPrototype, "length", "%TypedArrayPrototype%.length", "get length"); |
| verifyTypedArrayPrototypePropertyAccessor(typedArrayPrototype, Symbol.toStringTag, "%TypedArrayPrototype%[@@toStringTag]", "get [Symbol.toStringTag]"); |
| |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "set", 2, "%TypedArrayPrototype%.set"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "subarray", 2, "%TypedArrayPrototype%.subarray"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "copyWithin", 2, "%TypedArrayPrototype%.copyWithin"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "fill", 1, "%TypedArrayPrototype%.fill"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "map", 1, "%TypedArrayPrototype%.map"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "forEach", 1, "%TypedArrayPrototype%.forEach"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "indexOf", 1, "%TypedArrayPrototype%.indexOf"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "includes", 1, "%TypedArrayPrototype%.includes"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "every", 1, "%TypedArrayPrototype%.every"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "filter", 1, "%TypedArrayPrototype%.filter"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "find", 1, "%TypedArrayPrototype%.find"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "findIndex", 1, "%TypedArrayPrototype%.findIndex"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "join", 1, "%TypedArrayPrototype%.join"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "lastIndexOf", 1, "%TypedArrayPrototype%.lastIndexOf"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "reduce", 1, "%TypedArrayPrototype%.reduce"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "reduceRight", 1, "%TypedArrayPrototype%.reduceRight"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "reverse", 0, "%TypedArrayPrototype%.reverse"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "slice", 2, "%TypedArrayPrototype%.slice"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "some", 1, "%TypedArrayPrototype%.some"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, "sort", 1, "%TypedArrayPrototype%.sort"); |
| |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, 'entries', 0, "%TypedArrayPrototype%.entries"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, 'keys', 0, "%TypedArrayPrototype%.keys"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, 'values', 0, "%TypedArrayPrototype%.values"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, Symbol.iterator, 0, "%TypedArrayPrototype%[@@iterator]"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, 'toString', 0, "%TypedArrayPrototype%.toString"); |
| verifyTypedArrayPrototypePropertyFunction(typedArrayPrototype, 'toLocaleString', 0, "%TypedArrayPrototype%.toLocaleString"); |
| } |
| }, |
| { |
| name: "TypedArray constructors have correct properties", |
| body: function () { |
| function verifyTypedArrayConstructorPropertyValue(constructor, name, type, configurableIsTrue) { |
| var descriptor = Object.getOwnPropertyDescriptor(constructor, name); |
| var propName = constructor.name + "." + name; |
| |
| assert.isFalse(descriptor.writable, propName + ".writable === false"); |
| assert.isFalse(descriptor.enumerable, propName + ".enumerable === false"); |
| assert.areEqual(configurableIsTrue, descriptor.configurable, propName + ".configurable === " + configurableIsTrue); |
| assert.areEqual(type, typeof descriptor.value, "typeof " + propName + " === '" + type + "'"); |
| } |
| |
| assert.areEqual('Int8Array', Int8Array.name, "Int8Array.name === 'Int8Array'"); |
| assert.areEqual('Uint8Array', Uint8Array.name, "Uint8Array.name === 'Uint8Array'"); |
| assert.areEqual('Uint8ClampedArray', Uint8ClampedArray.name, "Uint8ClampedArray.name === 'Uint8ClampedArray'"); |
| assert.areEqual('Int16Array', Int16Array.name, "Int16Array.name === 'Int16Array'"); |
| assert.areEqual('Uint16Array', Uint16Array.name, "Uint16Array.name === 'Uint16Array'"); |
| assert.areEqual('Int32Array', Int32Array.name, "Int32Array.name === 'Int32Array'"); |
| assert.areEqual('Uint32Array', Uint32Array.name, "Uint32Array.name === 'Uint32Array'"); |
| assert.areEqual('Float32Array', Float32Array.name, "Float32Array.name === 'Float32Array'"); |
| assert.areEqual('Float64Array', Float64Array.name, "Float64Array.name === 'Float64Array'"); |
| |
| verifyTypedArrayConstructorPropertyValue(Int8Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Uint8Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Uint8ClampedArray, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Int16Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Uint16Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Int32Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Uint32Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Float32Array, "name", "string", true); |
| verifyTypedArrayConstructorPropertyValue(Float64Array, "name", "string", true); |
| |
| assert.areEqual(1, Int8Array.BYTES_PER_ELEMENT, "Int8Array.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(1, Uint8Array.BYTES_PER_ELEMENT, "Uint8Array.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(1, Uint8ClampedArray.BYTES_PER_ELEMENT, "Uint8ClampedArray.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(2, Int16Array.BYTES_PER_ELEMENT, "Int16Array.BYTES_PER_ELEMENT === 2"); |
| assert.areEqual(2, Uint16Array.BYTES_PER_ELEMENT, "Uint16Array.BYTES_PER_ELEMENT === 2"); |
| assert.areEqual(4, Int32Array.BYTES_PER_ELEMENT, "Int32Array.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(4, Uint32Array.BYTES_PER_ELEMENT, "Uint32Array.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(4, Float32Array.BYTES_PER_ELEMENT, "Float32Array.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(8, Float64Array.BYTES_PER_ELEMENT, "Float64Array.BYTES_PER_ELEMENT === 8"); |
| |
| verifyTypedArrayConstructorPropertyValue(Int8Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint8Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint8ClampedArray, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Int16Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint16Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Int32Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint32Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Float32Array, "BYTES_PER_ELEMENT", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Float64Array, "BYTES_PER_ELEMENT", "number", false); |
| |
| assert.areEqual(3, Int8Array.length, "Int8Array.length === 3"); |
| assert.areEqual(3, Uint8Array.length, "Uint8Array.length === 3"); |
| assert.areEqual(3, Uint8ClampedArray.length, "Uint8ClampedArray.length === 3"); |
| assert.areEqual(3, Int16Array.length, "Int16Array.length === 3"); |
| assert.areEqual(3, Uint16Array.length, "Uint16Array.length === 3"); |
| assert.areEqual(3, Int32Array.length, "Int32Array.length === 3"); |
| assert.areEqual(3, Uint32Array.length, "Uint32Array.length === 3"); |
| assert.areEqual(3, Float32Array.length, "Float32Array.length === 3"); |
| assert.areEqual(3, Float64Array.length, "Float64Array.length === 3"); |
| |
| verifyTypedArrayConstructorPropertyValue(Int8Array, "length", "number",false); |
| verifyTypedArrayConstructorPropertyValue(Uint8Array, "length", "number",false); |
| verifyTypedArrayConstructorPropertyValue(Uint8ClampedArray, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Int16Array, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint16Array, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Int32Array, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Uint32Array, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Float32Array, "length", "number", false); |
| verifyTypedArrayConstructorPropertyValue(Float64Array, "length", "number", false); |
| |
| verifyTypedArrayConstructorPropertyValue(Int8Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Uint8Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Uint8ClampedArray, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Int16Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Uint16Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Int32Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Uint32Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Float32Array, "prototype", "object", false); |
| verifyTypedArrayConstructorPropertyValue(Float64Array, "prototype", "object", false); |
| |
| function verifyTypedArrayConstructorDoesNotHaveOwnProperty(name, displayName) { |
| if(displayName === undefined) |
| displayName = name; |
| |
| assert.isFalse(Int8Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Uint8Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Uint8ClampedArray.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Int16Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Uint16Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Int32Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Uint32Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Float32Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| assert.isFalse(Float64Array.hasOwnProperty(name), "TypedArray constructors don't have own property named '" + displayName + "'"); |
| } |
| |
| verifyTypedArrayConstructorDoesNotHaveOwnProperty('to'); |
| verifyTypedArrayConstructorDoesNotHaveOwnProperty('from'); |
| verifyTypedArrayConstructorDoesNotHaveOwnProperty(Symbol.create, "@@create"); |
| } |
| }, |
| { |
| name: "TypedArray prototypes have correct properties", |
| body: function () { |
| function verifyTypedArrayPrototypePropertyValue(constructor, name, type) { |
| var descriptor = Object.getOwnPropertyDescriptor(constructor.prototype, name); |
| var propName = constructor.name + ".prototype." + name; |
| |
| assert.isFalse(descriptor.writable, propName + ".writable === false"); |
| assert.isFalse(descriptor.enumerable, propName + ".enumerable === false"); |
| assert.isFalse(descriptor.configurable, propName + ".configurable === false"); |
| assert.areEqual(type, typeof descriptor.value, "typeof " + propName + " === '" + type + "'"); |
| } |
| |
| assert.areEqual(1, Int8Array.prototype.BYTES_PER_ELEMENT, "Int8Array.prototype.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(1, Uint8Array.prototype.BYTES_PER_ELEMENT, "Uint8Array.prototype.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(1, Uint8ClampedArray.prototype.BYTES_PER_ELEMENT, "Uint8ClampedArray.prototype.BYTES_PER_ELEMENT === 1"); |
| assert.areEqual(2, Int16Array.prototype.BYTES_PER_ELEMENT, "Int16Array.prototype.BYTES_PER_ELEMENT === 2"); |
| assert.areEqual(2, Uint16Array.prototype.BYTES_PER_ELEMENT, "Uint16Array.prototype.BYTES_PER_ELEMENT === 2"); |
| assert.areEqual(4, Int32Array.prototype.BYTES_PER_ELEMENT, "Int32Array.prototype.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(4, Uint32Array.prototype.BYTES_PER_ELEMENT, "Uint32Array.prototype.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(4, Float32Array.prototype.BYTES_PER_ELEMENT, "Float32Array.prototype.BYTES_PER_ELEMENT === 4"); |
| assert.areEqual(8, Float64Array.prototype.BYTES_PER_ELEMENT, "Float64Array.prototype.BYTES_PER_ELEMENT === 8"); |
| |
| verifyTypedArrayPrototypePropertyValue(Int8Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Uint8Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Uint8ClampedArray, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Int16Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Uint16Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Int32Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Uint32Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Float32Array, "BYTES_PER_ELEMENT", "number"); |
| verifyTypedArrayPrototypePropertyValue(Float64Array, "BYTES_PER_ELEMENT", "number"); |
| |
| assert.areEqual(Int8Array, Int8Array.prototype.constructor, "Int8Array.prototype.constructor === Int8Array"); |
| assert.areEqual(Uint8Array, Uint8Array.prototype.constructor, "Uint8Array.prototype.constructor === Uint8Array"); |
| assert.areEqual(Uint8ClampedArray, Uint8ClampedArray.prototype.constructor, "Uint8ClampedArray.prototype.constructor === Uint8ClampedArray"); |
| assert.areEqual(Int16Array, Int16Array.prototype.constructor, "Int16Array.prototype.constructor === Int16Array"); |
| assert.areEqual(Uint16Array, Uint16Array.prototype.constructor, "Uint16Array.prototype.constructor === Uint16Array"); |
| assert.areEqual(Int32Array, Int32Array.prototype.constructor, "Int32Array.prototype.constructor === Int32Array"); |
| assert.areEqual(Uint32Array, Uint32Array.prototype.constructor, "Uint32Array.prototype.constructor === Uint32Array"); |
| assert.areEqual(Float32Array, Float32Array.prototype.constructor, "Float32Array.prototype.constructor === Float32Array"); |
| assert.areEqual(Float64Array, Float64Array.prototype.constructor, "Float64Array.prototype.constructor === Float64Array"); |
| |
| function verifyTypedArrayPrototypeDoesNotHaveOwnProperty(name, nameDesc) { |
| nameDesc = nameDesc || name; |
| assert.isFalse(Int8Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Uint8Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Uint8ClampedArray.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Int16Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Uint16Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Int32Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Uint32Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Float32Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| assert.isFalse(Float64Array.prototype.hasOwnProperty(name), "TypedArray prototypes don't have own property named '" + nameDesc + "'"); |
| } |
| |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('set'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('subarray'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('copyWithin'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('fill'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('map'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('indexOf'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('includes'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('forEach'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('every'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('filter'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('find'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('findIndex'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('join'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('lastIndexOf'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('reduce'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('reduceRight'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('reverse'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('slice'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('some'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('sort'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('buffer'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('byteLength'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('byteOffset'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('length'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty(Symbol.toStringTag, '@@toStringTag'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('entries'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('keys'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('values'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty(Symbol.iterator, '@@iterator'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('toString'); |
| verifyTypedArrayPrototypeDoesNotHaveOwnProperty('toLocaleString'); |
| } |
| }, |
| { |
| name: "TypedArray instances have the correct properties", |
| body: function() { |
| var int8Array = new Int8Array(20); |
| var uint8Array = new Uint8Array(20); |
| var uint8ClampedArray = new Uint8ClampedArray(20); |
| var uint16Array = new Uint16Array(20); |
| var int16Array = new Int16Array(20); |
| var int32Array = new Int32Array(20); |
| var uint32Array = new Uint32Array(20); |
| var float32Array = new Float32Array(20); |
| var float64Array = new Float64Array(20); |
| |
| function verifyInstancesDoNotHaveOwnProperty(propertyName, propertyDesc) { |
| propertyDesc = propertyDesc || propertyName; |
| |
| assert.isFalse(int8Array.hasOwnProperty(propertyName), "new Int8Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(uint8Array.hasOwnProperty(propertyName), "new Uint8Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(uint8ClampedArray.hasOwnProperty(propertyName), "new Uint8ClampedArray(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(int16Array.hasOwnProperty(propertyName), "new Int16Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(uint16Array.hasOwnProperty(propertyName), "new Uint16Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(int32Array.hasOwnProperty(propertyName), "new Int32Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(uint32Array.hasOwnProperty(propertyName), "new Uint32Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(float32Array.hasOwnProperty(propertyName), "new Float32Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| assert.isFalse(float64Array.hasOwnProperty(propertyName), "new Float64Array(20).hasOwnProperty('" + propertyDesc + "') === false"); |
| } |
| |
| // The accessors for buffer, byteLength, byteOffset, and length are inherited from prototype and are not instance properties |
| verifyInstancesDoNotHaveOwnProperty('buffer'); |
| verifyInstancesDoNotHaveOwnProperty('byteLength'); |
| verifyInstancesDoNotHaveOwnProperty('byteOffset'); |
| verifyInstancesDoNotHaveOwnProperty('length'); |
| verifyInstancesDoNotHaveOwnProperty(Symbol.toStringTag, '@@toStringTag'); |
| } |
| }, |
| { |
| name: "Properties shared between Array.prototype and %TypedArray%.prototype", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| |
| assert.areEqual(Array.prototype.toString, typedArrayPrototype.toString, "Array.prototype.toString === %TypedArray%.prototype.toString"); |
| assert.areEqual(Array.prototype.toLocaleString, typedArrayPrototype.toLocaleString, "Array.prototype.toLocaleString === %TypedArray%.prototype.toLocaleString"); |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype%.buffer behavior", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'buffer'); |
| |
| assert.throws(function () { typedArrayPrototype.buffer; }, TypeError, "%TypedArrayPrototype%.buffer throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get(); }, TypeError, "%TypedArrayPrototype%.buffer throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(); }, TypeError, "%TypedArrayPrototype%.buffer throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(undefined); }, TypeError, "%TypedArrayPrototype%.buffer throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call([1,2,3]); }, TypeError, "%TypedArrayPrototype%.buffer throws TypeError if called with a non-TypedArray parameter", "'this' is not a typed array object"); |
| |
| var buf = new ArrayBuffer(100); |
| assert.areEqual(buf, new Uint8Array(buf).buffer, "new Uint8Array(buf).buffer === buf"); |
| assert.areEqual(20, new Uint8Array(20).buffer.byteLength, "new Uint8Array(20).buffer.byteLength === 20"); |
| assert.areEqual(buf, descriptor.get.call(new Float32Array(buf)), "TypedArray.prototype.buffer can be used to retrieve the ArrayBuffer of a different TypedArray type"); |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype%.byteLength behavior", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteLength'); |
| |
| assert.throws(function () { typedArrayPrototype.byteLength; }, TypeError, "%TypedArrayPrototype%.byteLength throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get(); }, TypeError, "%TypedArrayPrototype%.byteLength throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(); }, TypeError, "%TypedArrayPrototype%.byteLength throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(undefined); }, TypeError, "%TypedArrayPrototype%.byteLength throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call([1,2,3]); }, TypeError, "%TypedArrayPrototype%.byteLength throws TypeError if called with a non-TypedArray parameter", "'this' is not a typed array object"); |
| |
| var buf = new ArrayBuffer(100); |
| assert.areEqual(100, new Uint8Array(buf).byteLength, "new Uint8Array(buf).byteLength === 100"); |
| assert.areEqual(80, new Uint32Array(20).byteLength, "new Uint8Array(20).byteLength === 80"); |
| assert.areEqual(100, descriptor.get.call(new Float32Array(buf)), "TypedArray.prototype.byteLength can be used to retrieve the byte length of a different TypedArray type"); |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype%.byteOffset behavior", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteOffset'); |
| |
| assert.throws(function () { typedArrayPrototype.byteOffset; }, TypeError, "%TypedArrayPrototype%.byteOffset throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get(); }, TypeError, "%TypedArrayPrototype%.byteOffset throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(); }, TypeError, "%TypedArrayPrototype%.byteOffset throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(undefined); }, TypeError, "%TypedArrayPrototype%.byteOffset throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call([1,2,3]); }, TypeError, "%TypedArrayPrototype%.byteOffset throws TypeError if called with a non-TypedArray parameter", "'this' is not a typed array object"); |
| |
| var buf = new ArrayBuffer(100); |
| assert.areEqual(0, new Uint8Array(buf).byteOffset, "new Uint8Array(buf).byteOffset === 0"); |
| assert.areEqual(0, new Uint16Array(20).byteOffset, "new Uint16Array(20).byteOffset === 0"); |
| assert.areEqual(8, new Uint32Array(buf, 8).byteOffset, "new Uint8Array(buf).byteOffset === 8"); |
| assert.areEqual(0, descriptor.get.call(new Float32Array(buf)), "TypedArray.prototype.byteOffset can be used to retrieve the byte offset of a different TypedArray type"); |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype%.length behavior", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'length'); |
| |
| assert.throws(function () { typedArrayPrototype.length; }, TypeError, "%TypedArrayPrototype%.length throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get(); }, TypeError, "%TypedArrayPrototype%.length throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(); }, TypeError, "%TypedArrayPrototype%.length throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call(undefined); }, TypeError, "%TypedArrayPrototype%.length throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.throws(function () { descriptor.get.call([1,2,3]); }, TypeError, "%TypedArrayPrototype%.length throws TypeError if called with a non-TypedArray parameter", "'this' is not a typed array object"); |
| |
| var buf = new ArrayBuffer(100); |
| assert.areEqual(100, new Uint8Array(buf).length, "new Uint8Array(buf).length === 100"); |
| assert.areEqual(20, new Uint32Array(20).length, "new Uint32Array(20).length === 20"); |
| assert.areEqual(50, descriptor.get.call(new Uint16Array(buf)), "TypedArray.prototype.length can be used to retrieve the length of a different TypedArray type"); |
| } |
| }, |
| { |
| name: "%TypedArrayPrototype%[@@toStringTag] behavior", |
| body: function() { |
| var typedArrayPrototype = Int8Array.prototype.__proto__; |
| var descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag); |
| |
| assert.throws(function () { typedArrayPrototype.length; }, TypeError, "%TypedArrayPrototype%[length] throws TypeError if called with no parameter", "'this' is not a typed array object"); |
| assert.areEqual(undefined, descriptor.get.call(), "%TypedArrayPrototype%[@@toStringTag] returns undefined if called with no parameter"); |
| |
| assert.areEqual('Int8Array', new Int8Array(10)[Symbol.toStringTag], "new Int8Array()[@@toStringTag] === 'Int8Array'"); |
| assert.areEqual('Uint8Array', new Uint8Array(10)[Symbol.toStringTag], "new Uint8Array()[@@toStringTag] === 'Uint8Array'"); |
| assert.areEqual('Uint8ClampedArray', new Uint8ClampedArray(10)[Symbol.toStringTag], "new Uint8ClampedArray()[@@toStringTag] === 'Uint8ClampedArray'"); |
| assert.areEqual('Int16Array', new Int16Array(10)[Symbol.toStringTag], "new Int16Array()[@@toStringTag] === 'Int16Array'"); |
| assert.areEqual('Uint16Array', new Uint16Array(10)[Symbol.toStringTag], "new Uint16Array()[@@toStringTag] === 'Uint16Array'"); |
| assert.areEqual('Int32Array', new Int32Array(10)[Symbol.toStringTag], "new Int32Array()[@@toStringTag] === 'Int32Array'"); |
| assert.areEqual('Uint32Array', new Uint32Array(10)[Symbol.toStringTag], "new Uint32Array()[@@toStringTag] === 'Uint32Array'"); |
| assert.areEqual('Float32Array', new Float32Array(10)[Symbol.toStringTag], "new Float32Array()[@@toStringTag] === 'Float32Array'"); |
| assert.areEqual('Float64Array', new Float64Array(10)[Symbol.toStringTag], "new Float64Array()[@@toStringTag] === 'Float64Array'"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from basic behavior", |
| body: function() { |
| assert.areEqual([0,1,2,3], Uint8Array.from([0,1,2,3]), "%TypedArray%.from basic behavior with an iterable object"); |
| assert.areEqual([0,1,2,3], Uint8Array.from({ 0: 0, 1: 1, 2: 2, 3: 3, length: 4 }), "%TypedArray%.from basic behavior with an object with length but no iterator"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from extended behavior", |
| body: function() { |
| var fromFnc = Uint8Array.__proto__.from; |
| |
| var b = fromFnc.call(Float64Array, [1,2,3,4,5,6]); |
| assert.areEqual('object', typeof b, "%TypedArray%.from.call(Float64Array, 'string') returns a Float64Array"); |
| assert.areEqual([1,2,3,4,5,6], b, "%TypedArray%.from.call(Float64Array, 'string') == [1,2,3,4,5,6]"); |
| assert.areEqual(6, b.length, "%TypedArray%.from.call(Float64Array, 'string').length === 6"); |
| assert.isTrue(ArrayBuffer.isView(b) && b instanceof Float64Array, "%TypedArray%.from.call(Float64Array, 'string') is a Float64Array"); |
| |
| var a = { 0: 0, 1: 1, 2: 2, length: 5 }; |
| var b = fromFnc.call(Uint8Array, a); |
| assert.areEqual(5, b.length, "Uint8Array.from(objectWithLengthProperty) returns a new Uint8Array with length = a.length"); |
| assert.isTrue(ArrayBuffer.isView(b), "Uint8Array.from(objectWithLengthProperty) returns a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual(5, b.byteLength, "Uint8Array.from(objectWithLengthProperty) returns a TypedArray (with correct byteLength)"); |
| assert.areEqual([0,1,2,0,0], b, "Uint8Array.from(objectWithLengthProperty) has missing values set to 0"); |
| |
| var a = { 0: 0, 1: 1, 2: 2, length: 5 }; |
| var b = fromFnc.call(Float64Array, a); |
| assert.areEqual('object', typeof b, "%TypedArray%.from.call(Float64Array, objectWithLengthProperty) returns an object"); |
| assert.areEqual(5, b.length, "%TypedArray%.from.call(Float64Array, objectWithLengthProperty) returns a new typed array with length = a.length"); |
| assert.isTrue(ArrayBuffer.isView(b) && b instanceof Float64Array, "%TypedArray%.from.call(Float64Array, objectWithLengthProperty) is a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual([0,1,2,NaN,NaN], b, "%TypedArray%.from.call(Float64Array, objectWithLengthProperty) has missing values set to undefined"); |
| |
| var a = { 0: 0, 1: 1 }; |
| var b = fromFnc.call(Float64Array, a); |
| assert.areEqual('object', typeof b, "%TypedArray%.from.call(Float64Array, objectWithLengthNoProperty) returns an object"); |
| assert.areEqual(0, b.length, "%TypedArray%.from.call(Float64Array, objectWithLengthNoProperty) returns a new Float64Array with length = 0"); |
| assert.isTrue(ArrayBuffer.isView(b) && b instanceof Float64Array, "%TypedArray%.from.call(Float64Array, objectWithLengthNoProperty) is a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual([], b, "%TypedArray%.from.call(Float64Array, objectWithLengthNoProperty) is an empty array"); |
| |
| assert.throws(function () { fromFnc.call(); }, TypeError, "Calling %TypedArray%.from with no this throws TypeError", "[TypedArray].from: 'this' is not a Function object"); |
| assert.throws(function () { fromFnc.call(undefined); }, TypeError, "Calling %TypedArray%.from with undefined this throws TypeError", "[TypedArray].from: 'this' is not a Function object"); |
| assert.throws(function () { fromFnc.call('string'); }, TypeError, "Calling %TypedArray%.from with non-function this throws TypeError", "[TypedArray].from: 'this' is not a Function object"); |
| assert.throws(function () { fromFnc.call(Math.sin, []); }, TypeError, "Calling %TypedArray%.from with non-constructor this function throws TypeError", "[TypedArray].from: 'this' is not a Function object"); |
| assert.throws(function () { Uint8Array.from(); }, TypeError, "Calling %TypedArray%.from with non-object items argument throws TypeError", "[TypedArray].from: argument is not an Object"); |
| assert.throws(function () { Uint8Array.from(undefined); }, TypeError, "Calling %TypedArray%.from with non-object items argument throws TypeError", "[TypedArray].from: argument is not an Object"); |
| assert.throws(function () { Uint8Array.from(null); }, TypeError, "Calling %TypedArray%.from with non-object items argument throws TypeError", "[TypedArray].from: argument is not an Object"); |
| assert.throws(function () { Uint8Array.from({}, undefined); }, TypeError, "Calling %TypedArray%.from with non-object mapFn argument throws TypeError", "[TypedArray].from: argument is not a Function object"); |
| assert.throws(function () { Uint8Array.from({}, null); }, TypeError, "Calling %TypedArray%.from with non-object mapFn argument throws TypeError", "[TypedArray].from: argument is not a Function object"); |
| assert.throws(function () { Uint8Array.from({}, 'string'); }, TypeError, "Calling %TypedArray%.from with non-object mapFn argument throws TypeError", "[TypedArray].from: argument is not a Function object"); |
| assert.throws(function () { Uint8Array.from({}, {}); }, TypeError, "Calling %TypedArray%.from with non-function mapFn argument throws TypeError", "[TypedArray].from: argument is not a Function object"); |
| assert.throws(function () { fromFnc.call(String, [0,1,2,3]); }, TypeError, "Calling %TypedArray%.from with no this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from calls down into correct TypedArray SetItem API", |
| body: function() { |
| var u = Uint8ClampedArray.from([0,-1,2,300]); |
| assert.areEqual(4, u.length, "Uint8ClampedArray.from([0,-1,2,300]) returns a new Uint8ClampedArray with length = 4"); |
| assert.isTrue(ArrayBuffer.isView(u), "Uint8ClampedArray.from([0,-1,2,300]) returns a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual(4, u.byteLength, "Uint8ClampedArray.from([0,-1,2,300]) returns a TypedArray (with correct byteLength)"); |
| assert.areEqual([0,0,2,255], u, "Uint8ClampedArray.from([0,-1,2,300]) has the correct values"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from behavior with iterable source item", |
| body: function() { |
| var fromFnc = Uint8Array.__proto__.from; |
| var objectWithIterator = { |
| [Symbol.iterator]: function() { |
| return { |
| i: 0, |
| next: function () { |
| return { |
| done: this.i == 5, |
| value: this.i++ |
| }; |
| } |
| }; |
| } |
| }; |
| |
| var b = fromFnc.call(Uint8Array, objectWithIterator); |
| assert.areEqual(5, b.length, "%TypedArray%.from.call(Uint8Array, objectWithIterator) returns a new Uint8Array with length = objectWithIterator.length"); |
| assert.isTrue(ArrayBuffer.isView(b), "%TypedArray%.from(objectWithIterator) returns a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual(5, b.byteLength, "%TypedArray%.from(objectWithIterator) returns a TypedArray (with correct byteLength)"); |
| assert.areEqual([0,1,2,3,4], b, "%TypedArray%.from(objectWithIterator) has correct values"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from behavior with iterable source item which doesn't hold references to objects it returns", |
| body: function() { |
| var fromFnc = Uint8Array.__proto__.from; |
| var objectWithIterator = { |
| [Symbol.iterator]: function() { |
| return { |
| i: 0, |
| next: function () { |
| CollectGarbage(); |
| return { |
| done: this.i == 10, |
| value: this.i++ |
| }; |
| } |
| }; |
| } |
| }; |
| |
| var b = fromFnc.call(Float64Array, objectWithIterator); |
| assert.areEqual(10, b.length, "%TypedArray%.from.call(Float64Array, objectWithIterator) returns a new Float64Array with length = objectWithIterator.length"); |
| for (var i = 0; i < b.length; i++) { |
| assert.isTrue(b[i] !== undefined, "Object at index " + i + " is not undefined"); |
| assert.areEqual('number', typeof b[i], "Object at index " + i + " is a number"); |
| assert.areEqual(i, b[i], "Object at index " + i + " has correct value"); |
| } |
| } |
| }, |
| // { |
| // name: "%TypedArray%.from order of operations test via proxy traps", |
| // body: function() { |
| // var fromFnc = Uint8Array.__proto__.from; |
| // var obj = [0, 1, 2, 3, 4]; |
| // var currentIndex = 0; |
| // var proxyHandler = { |
| // get: function(target, name, receiver) { |
| // assert.isTrue(currentIndex < name, "We should be accessing the elements of obj in order."); |
| // return receiver[name]; |
| // } |
| // }; |
| // var proxyObj = Proxy(obj, proxyHandler); |
| |
| // var b = fromFnc.call(Array, proxyObj); |
| // assert.areEqual(10, b.length, "%TypedArray%.from(proxyObj) returns a new Array with length = obj.length"); |
| // for (var i = 0; i < b.length; i++) { |
| // assert.isTrue(b[i] !== undefined, "Object at index " + i + " is not undefined"); |
| // assert.areEqual('object', typeof b[i], "Object at index " + i + " is an object"); |
| // assert.areEqual(i, b[i].myi, "Object at index " + i + " has correct value"); |
| // } |
| // } |
| // }, |
| { |
| name: "%TypedArray%.from behavior with a map function", |
| body: function() { |
| var i = 0; |
| |
| function mapFunction(val, k) { |
| assert.areEqual(i, k, "%TypedArray%.from called with a mapping function, we should get the elements in order. Setting item[" + k + "] = " + val); |
| assert.areEqual(val, k, "Value and index should be same for this test"); |
| assert.areEqual(2, arguments.length, "%TypedArray%.from called with a mapping function, only 2 arguments should be passed to the map function"); |
| |
| // increment expected index |
| i++; |
| } |
| |
| var objectWithoutIterator = { |
| 0: 0, |
| 1: 1, |
| 2: 2, |
| 3: 3, |
| length: 4 |
| }; |
| |
| // Verify mapFunction gets called with correct arguments |
| Int8Array.from(objectWithoutIterator, mapFunction); |
| } |
| }, |
| { |
| name: "%TypedArray%.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 %TypedArray%.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 |
| Int8Array.from(objectWithoutIterator, mapFunction, thisArg); |
| } |
| }, |
| { |
| name: "%TypedArray%.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,0], Int32Array.from(objectWithoutIterator, mapFunction), "Int32Array.from called with a map function that mutates the source object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.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, "%TypedArray%.from called with a mapping function, we should get the elements in order. Setting item[" + j + "] = " + val); |
| assert.areEqual(val, val, "%TypedArray%.from called with a mapping function, index should be equal to the value passed in."); |
| assert.areEqual(2, arguments.length, "%TypedArray%.from called with a mapping function, only 2 arguments should be passed to the map function."); |
| |
| // increment expected value |
| j++; |
| |
| if (checkThisArg) { |
| // this will be wrapped as an Object |
| assert.areEqual(Object(thisArg), this, "thisArg passed into %TypedArray%.from should flow into mapFunction"); |
| } |
| } |
| |
| // Verify mapFunction gets called with correct arguments |
| Int8Array.from(objectWithIterator, mapFunction); |
| |
| j = 0; |
| checkThisArg = true; |
| |
| // Verify mapFunction gets called with thisArg passed as this |
| Int8Array.from(objectWithIterator, mapFunction, thisArg); |
| } |
| }, |
| { |
| name: "%TypedArray%.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,3,4], Int8Array.from(objectWithIterator, mapFunction), "Int8Array.from called with map function which alters iterator state"); |
| } |
| }, |
| { |
| name: "%TypedArray%.from behavior with badly formed iterator objects", |
| body: function() { |
| // Test GetIterator where obj[@@iterator] is not a function |
| var objectWithIteratorThatIsNotAFunction = { |
| [Symbol.iterator]: 'a string' |
| }; |
| assert.throws(function() { Int8Array.from(objectWithIteratorThatIsNotAFunction); }, TypeError, "obj[@@iterator] must be a function", "Function expected"); |
| |
| // Test GetIterator where obj[@@iterator] is a function which doesn't return an object |
| var objectWithIteratorWhichDoesNotReturnObjects = { |
| [Symbol.iterator]: function() { |
| return undefined; |
| } |
| }; |
| assert.throws(function() { Int8Array.from(objectWithIteratorWhichDoesNotReturnObjects); }, TypeError, "obj[@@iterator] must return an object", "Object expected"); |
| |
| // Test IteratorNext where obj[@@iterator].next is not a function |
| var objectWithIteratorNextIsNotAFunction = { |
| [Symbol.iterator]: function() { |
| return { |
| next: undefined |
| }; |
| } |
| }; |
| assert.throws(function() { Int8Array.from(objectWithIteratorNextIsNotAFunction); }, TypeError, "obj[@@iterator].next must be a function", "Function expected"); |
| |
| // Test IteratorNext where obj[@@iterator].next doesn't return an object |
| var objectWithIteratorNextDoesNotReturnObjects = { |
| [Symbol.iterator]: function() { |
| return { |
| next: function() { |
| return undefined; |
| } |
| }; |
| } |
| }; |
| assert.throws(function() { Int8Array.from(objectWithIteratorNextDoesNotReturnObjects); }, TypeError, "obj[@@iterator].next must return an object", "Object expected"); |
| } |
| }, |
| { |
| name: "%TypedArray%.of basic behavior", |
| body: function() { |
| assert.areEqual([], Uint8Array.of(), "%TypedArray%.of basic behavior with no arguments"); |
| assert.areEqual([3], Uint8Array.of(3), "%TypedArray%.of basic behavior with a single argument"); |
| assert.areEqual([0,1,2,3], Uint8Array.of(0, 1, 2, 3), "%TypedArray%.of basic behavior with a list of arguments"); |
| } |
| }, |
| { |
| name: "%TypedArray%.of extended behavior", |
| body: function() { |
| var ofFnc = Uint8Array.__proto__.of; |
| |
| var u = ofFnc.call(Uint8ClampedArray, 0, -1, 2, 300, 4); |
| assert.areEqual(5, u.length, "Uint8ClampedArray.of(0, -1, 2, 300, 4) returns a new Uint8ClampedArray with length = 5"); |
| assert.isTrue(ArrayBuffer.isView(u), "Uint8ClampedArray.of(0, -1, 2, 300, 4) returns a TypedArray (ArrayBuffer.isView)"); |
| assert.areEqual(5, u.byteLength, "Uint8ClampedArray.of(0, -1, 2, 300, 4) returns a TypedArray (with correct byteLength)"); |
| assert.areEqual([0,0,2,255,4], u, "Uint8ClampedArray.of(0, -1, 2, 300, 4) has the correct values"); |
| |
| var b = Uint8Array.of(); |
| assert.areEqual(0, b.length, "Uint8Array.of() returns empty Uint8Array"); |
| assert.areEqual(0, b.byteLength, "Uint8Array.of() returns empty Uint8Array"); |
| assert.isTrue(ArrayBuffer.isView(b), "Uint8Array.of() returns actual TypedArray"); |
| assert.areEqual(Uint8Array, b.constructor, "Uint8Array.of() returns correct TypedArray type"); |
| |
| assert.throws(function () { ofFnc.call(); }, TypeError, "Calling %TypedArray%.of with no this throws TypeError", "[TypedArray].of: 'this' is not a Function object"); |
| assert.throws(function () { ofFnc.call(undefined); }, TypeError, "Calling %TypedArray%.of with undefined this throws TypeError", "[TypedArray].of: 'this' is not a Function object"); |
| assert.throws(function () { ofFnc.call('string'); }, TypeError, "Calling %TypedArray%.of with non-object this throws TypeError", "[TypedArray].of: 'this' is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.copyWithin behavior", |
| body: function() { |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i+1; |
| } |
| |
| return t; |
| } |
| |
| function getRegularArray() { |
| return [1,2,3,4,5,6,7,8,9,10]; |
| } |
| |
| function getObjectArray() { |
| return { |
| 0:1, 1:2, 2:3, 3:4, 4:5, 5:6, 6:7, 7:8, 8:9, 9:10, length: 10 |
| }; |
| } |
| |
| function testMethod(copyWithinFn, getDataFn) { |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn()), "%TypedArrayPrototype%.copyWithin copying the entire array to the first index returns the same array"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0), "%TypedArrayPrototype%.copyWithin copying the entire array to the first index returns the same array"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 0), "%TypedArrayPrototype%.copyWithin copying the entire array to the first index returns the same array"); |
| assert.areEqual([6,7,8,9,10,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5), "%TypedArrayPrototype%.copyWithin copying the entire array beginning at index 5 to the first index"); |
| assert.areEqual([6,7,8,9,10,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, 10), "%TypedArrayPrototype%.copyWithin copying the entire array beginning at index 5 to the first index"); |
| assert.areEqual([6,7,8,9,10,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, 11), "%TypedArrayPrototype%.copyWithin copying the entire array beginning at index 5 to the first index"); |
| assert.areEqual([6,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), -50, 5, 6), "%TypedArrayPrototype%.copyWithin copying a single element beginning at index 5 to the first index"); |
| assert.areEqual([6,7,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), -10, 5, 7), "%TypedArrayPrototype%.copyWithin copying two elements beginning at index 5 to the first index"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, 3), "%TypedArrayPrototype%.copyWithin copying elements where end > start causes no changes"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, 5), "%TypedArrayPrototype%.copyWithin copying elements where end = start causes no changes"); |
| assert.areEqual([6,7,8,9,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, 9), "%TypedArrayPrototype%.copyWithin copying elements where end = arr.length-1"); |
| assert.areEqual([6,7,8,9,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 0, 5, -1), "%TypedArrayPrototype%.copyWithin copying elements where end -1 is the same as end === arr.length-1"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,6], copyWithinFn.call(getDataFn(), -1, 5), "%TypedArrayPrototype%.copyWithin copying from the middle of the array to the last index"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), -5, 5, -1), "%TypedArrayPrototype%.copyWithin copying the middle of the array to the last index - 1"); |
| assert.areEqual([1,6,7,8,9,6,7,8,9,10], copyWithinFn.call(getDataFn(), 1, -5, -1), "%TypedArrayPrototype%.copyWithin copying the middle of the array to the last index - 1"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 1, 0, -10), "%TypedArrayPrototype%.copyWithin copying anything where end is 0 or less causes us to do nothing"); |
| assert.areEqual([1,1,2,4,5,6,7,8,9,10], copyWithinFn.call(getDataFn(), 1, -100, 2), "%TypedArrayPrototype%.copyWithin copying two elements starting at 0 into start position 1"); |
| assert.areEqual([2,3,4,5,6,7,8,9,10,10], copyWithinFn.call(getDataFn(), 0, -9), "%TypedArrayPrototype%.copyWithin copying all but the last elements starting at 1 into start position 0"); |
| } |
| |
| testMethod(Uint8Array.prototype.__proto__.copyWithin, getTypedArray); |
| testMethod(Array.prototype.copyWithin, getRegularArray); |
| testMethod(Array.prototype.copyWithin, getTypedArray); |
| |
| var copyWithinFn = Uint8Array.prototype.__proto__.copyWithin; |
| |
| assert.isTrue(ArrayBuffer.isView(copyWithinFn.call(getTypedArray(), 0, 0)), "%TypedArrayPrototype%.copyWithin returns a TypedArray"); |
| assert.areEqual("Int8Array", copyWithinFn.call(getTypedArray(), 0, 0)[Symbol.toStringTag], "%TypedArrayPrototype%.copyWithin returns the right TypedArray type"); |
| |
| assert.isTrue(ArrayBuffer.isView(Array.prototype.copyWithin.call(getTypedArray(), 0, 0)), "Array.prototype.copyWithin returns a TypedArray when a TypedArray is passed in"); |
| assert.isFalse(ArrayBuffer.isView(Array.prototype.copyWithin.call(getRegularArray(), 0, 0)), "Array.prototype.copyWithin returns a normal array when a TypedArray is not passed in"); |
| assert.isFalse(ArrayBuffer.isView(Array.prototype.copyWithin.call(getObjectArray(), 0, 0)), "Array.prototype.copyWithin returns a normal array when a TypedArray is not passed in"); |
| |
| assert.throws(function() { copyWithinFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.copyWithin with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { copyWithinFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.copyWithin with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { copyWithinFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.copyWithin with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { copyWithinFn.call(getRegularArray()); }, TypeError, "Calling %TypedArrayPrototype%.copyWithin with non-TypedArray object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { copyWithinFn.call(getObjectArray()); }, TypeError, "Calling %TypedArrayPrototype%.copyWithin with non-TypedArray object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.fill behavior", |
| body: function() { |
| var fill = Uint8Array.prototype.__proto__.fill; |
| |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i+1; |
| } |
| |
| return t; |
| } |
| |
| function testMethod(getDataFn) { |
| assert.areEqual([0,0,0,0,0,0,0,0,0,0], fill.call(getDataFn(), 0), "%TypedArrayPrototype%.fill filling the entire array with 0"); |
| assert.areEqual([0,0,0,0,0,0,0,0,0,0], fill.call(getDataFn(), 0, undefined), "%TypedArrayPrototype%.fill should use length as the end value when undefined is specified"); |
| assert.areEqual([0,0,0,0,0,0,0,0,0,0], fill.call(getDataFn(), 0, 0), "%TypedArrayPrototype%.fill filling the entire array with 0"); |
| assert.areEqual([0,0,0,0,0,0,0,0,0,0], fill.call(getDataFn(), 0, 0, 100), "%TypedArrayPrototype%.fill filling the entire array with 0"); |
| assert.areEqual([0,0,0,0,0,0,0,0,0,0], fill.call(getDataFn(), 0, -50), "%TypedArrayPrototype%.fill filling the entire array with 0"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], fill.call(getDataFn(), 0, 100), "%TypedArrayPrototype%.fill filling no elements because start > length"); |
| assert.areEqual([1,2,3,4,5,0,0,0,0,0], fill.call(getDataFn(), 0, 5), "%TypedArrayPrototype%.fill filling all elements after index 5"); |
| assert.areEqual([0,0,0,0,0,6,7,8,9,10], fill.call(getDataFn(), 0, 0, 5), "%TypedArrayPrototype%.fill filling first 5 elements"); |
| assert.areEqual([1,2,3,0,5,6,7,8,9,10], fill.call(getDataFn(), 0, 3, 4), "%TypedArrayPrototype%.fill filling one element at index 3"); |
| assert.areEqual([1,2,3,4,5,6,7,0,0,10], fill.call(getDataFn(), 0, -3, -1), "%TypedArrayPrototype%.fill filling two elements near the end"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,0], fill.call(getDataFn(), 0, -1), "%TypedArrayPrototype%.fill filling the last element"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], fill.call(getDataFn(), 0, 5, 4), "%TypedArrayPrototype%.fill filling the no elements because start > end"); |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], fill.call(getDataFn(), 0, 4, 4), "%TypedArrayPrototype%.fill filling the no elements because start == end"); |
| } |
| |
| testMethod(getTypedArray); |
| |
| assert.throws(function() { fill.call(); }, TypeError, "Calling %TypedArrayPrototype%.fill with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { fill.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.fill with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { fill.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.fill with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.map behavior", |
| body: function() { |
| var mapFn = Int8Array.prototype.__proto__.map; |
| var counter = 0; |
| var t; |
| var thisArg = 'a string'; |
| |
| function getTypedArray() { |
| // Reset the counter var here |
| counter = 0; |
| // Save the latest array in t for use by the mapping function |
| t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function mappingFn(elem, index, arr) { |
| assert.areEqual(index, counter, "We call the mapping function on elements in the correct order"); |
| assert.areEqual(elem, index, "We pass the correct values to the mapping function"); |
| assert.isTrue(arr === t, "Array passed to the mapping function matches array map is called on"); |
| assert.areEqual(Object(thisArg), this, "This value passed to map is correct"); |
| |
| // Increment counter var for the next index |
| counter++; |
| |
| return -1 * elem; |
| } |
| |
| function testMethod(testFn, getDataFn, isReturnTypedArray) { |
| assert.areEqual([0,-1,-2,-3,-4,-5,-6,-7,-8,-9], testFn.call(getDataFn(), mappingFn, thisArg), "%TypedArrayPrototype%.map basic functionality of the mapping function"); |
| |
| if (isReturnTypedArray) { |
| assert.isTrue(ArrayBuffer.isView(testFn.call(getDataFn(), mappingFn, thisArg)), "%TypedArrayPrototype%.map returns a TypedArray"); |
| assert.areEqual("Int8Array", testFn.call(getDataFn(), mappingFn, thisArg)[Symbol.toStringTag], "%TypedArrayPrototype%.map returns the right TypedArray type"); |
| } else { |
| assert.isFalse(ArrayBuffer.isView(testFn.call(getDataFn(), mappingFn, thisArg)), "%TypedArrayPrototype%.map returns a normal array"); |
| } |
| } |
| |
| testMethod(mapFn, getTypedArray, true); |
| testMethod(Array.prototype.map, getTypedArray, false); |
| |
| // %TypedArray%.prototype.map loads the constructor property from the this parameter and uses that to construct the return value. |
| // If we set the constructor property of some TypedArray to Array built-in constructor, we should get an array object out. |
| var u = getTypedArray(); |
| u.constructor = Array; |
| assert.throws(()=>u.map(mappingFn, thisArg), TypeError, 'u.map', "'this' is not a typed array object"); |
| |
| u.constructor = Int16Array; |
| var r = u.map(mappingFn, thisArg); |
| |
| assert.areEqual([0,-1,-2,-3,-4,-5,-6,-7,-8,-9], r, "%TypedArrayPrototype%.map called on a TypedArray with 'constructor' property set to Array produces the correct values"); |
| assert.isTrue(ArrayBuffer.isView(r) && r instanceof Int16Array, "%TypedArrayPrototype%.map called on a TypedArray with 'constructor' property set to a different TypedArray produces a typed array"); |
| |
| // %TypedArray%.prototype.map loads the constructor property from the this parameter and uses that to construct the return value. |
| // If we set the constructor property of some TypedArray to a non-constructor, it should throw. |
| var u = getTypedArray(); |
| u.constructor = undefined; |
| assert.doesNotThrow(function() { u.map(mappingFn, thisArg); }, "With [@@species], calling %TypedArrayPrototype%.map with a constructor property on this which is not IsConstructor does not throw"); |
| |
| assert.throws(function() { mapFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.map with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { mapFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.map with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { mapFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.map with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { mapFn.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.map with no callback function throws TypeError", "[TypedArray].prototype.map: argument is not a Function object"); |
| assert.throws(function() { mapFn.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.map with undefined callback function throws TypeError", "[TypedArray].prototype.map: argument is not a Function object"); |
| assert.throws(function() { mapFn.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.map with non-function callback function throws TypeError", "[TypedArray].prototype.map: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "Array.prototype.map called with a TypedArray which lies about length", |
| body: function() { |
| // We have to make sure that we don't rely on the TypedArray internal length slot when passing a TypedArray object |
| // to Array.prototype.map as the this argument. The object might lie about the length property. |
| var mapFn = Array.prototype.map; |
| var counter = 0; |
| var t; |
| var thisArg = 'a string'; |
| |
| function getTypedArray() { |
| // Reset the counter var here |
| counter = 0; |
| // Save the latest array in t for use by the mapping function |
| t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function mappingFn(elem, index, arr) { |
| assert.areEqual(index, counter, "We call the mapping function on elements in the correct order"); |
| assert.areEqual(elem, index, "We pass the correct values to the mapping function"); |
| assert.isTrue(arr === t, "Array passed to the mapping function matches array map is called on"); |
| assert.areEqual(Object(thisArg), this, "This value passed to map is correct"); |
| |
| // Increment counter var for the next index |
| counter++; |
| |
| return -1 * elem; |
| } |
| |
| // This object lies and says it has length of 5 (while the internal length slot is 10) |
| var ui8 = new getTypedArray(); |
| Object.defineProperty(ui8, 'length', { value: 5 }); |
| |
| // Since Array.prototype.map doesn't care about TypedArrays and always gets the length property, |
| // result array should only have 5 elements. |
| var res = mapFn.call(ui8, mappingFn, thisArg); |
| |
| assert.areEqual([0,-1,-2,-3,-4], res, "Array.prototype.map called with a TypedArray object which lies about length"); |
| assert.isFalse(ArrayBuffer.isView(res), "Array.prototype.map returns a normal array object even if the this parameter is a TypedArray"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.forEach behavior", |
| body: function() { |
| var forEachFn = Int8Array.prototype.__proto__.forEach; |
| var counter = 0; |
| var t; |
| var thisArg = 'a string'; |
| var verifyThisArg = true; |
| |
| function callbackFn(val, k, arr) { |
| assert.areEqual(counter, val, "Callback function is called on elements in the correct order"); |
| assert.areEqual(k, val, "Callback function is called on elements in the correct order"); |
| assert.isTrue(t === arr, "Callback function is called with the correct TypedArray object"); |
| |
| if (verifyThisArg) { |
| assert.areEqual(Object(thisArg), this, "Callback function has this set correctly"); |
| } |
| |
| counter++; |
| } |
| |
| function getTypedArray() { |
| // Reset the counter var here |
| counter = 0; |
| // Save the latest array in t for use by the callback function |
| t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual(undefined, forEachFn.call(getTypedArray(), callbackFn, thisArg), "Calling %TypedArrayPrototype%.forEach with a simple callback function and this arg"); |
| assert.areEqual(10, counter, "We called the callback function the correct number of times"); |
| |
| verifyThisArg = false; |
| assert.areEqual(undefined, forEachFn.call(getTypedArray(), callbackFn), "Calling %TypedArrayPrototype%.forEach with a simple callback function"); |
| assert.areEqual(10, counter, "We called the callback function the correct number of times"); |
| |
| assert.throws(function() { forEachFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.forEach with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { forEachFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.forEach with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { forEachFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.forEach with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { forEachFn.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.forEach with no callback function throws TypeError", "[TypedArray].prototype.forEach: argument is not a Function object"); |
| assert.throws(function() { forEachFn.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.forEach with undefined callback function throws TypeError", "[TypedArray].prototype.forEach: argument is not a Function object"); |
| assert.throws(function() { forEachFn.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.forEach with non-function callback function throws TypeError", "[TypedArray].prototype.forEach: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.indexOf behavior", |
| body: function() { |
| var indexOfFn = Int8Array.prototype.__proto__.indexOf; |
| |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual(-1, indexOfFn.call(getTypedArray(), undefined), "Calling %TypedArrayPrototype%.indexOf with undefined returns -1"); |
| assert.areEqual(0, indexOfFn.call(getTypedArray(), 0), "Calling %TypedArrayPrototype%.indexOf searching for the first value"); |
| assert.areEqual(9, indexOfFn.call(getTypedArray(), 9), "Calling %TypedArrayPrototype%.indexOf searching for the last value"); |
| assert.areEqual(-1, indexOfFn.call(getTypedArray(), 0, 1), "Calling %TypedArrayPrototype%.indexOf searching for the first value but skipping the first element returns -1"); |
| assert.areEqual(-1, indexOfFn.call(getTypedArray(), 0, 11), "Calling %TypedArrayPrototype%.indexOf where fromIndex > length returns -1"); |
| assert.areEqual(0, indexOfFn.call(getTypedArray(), 0, -10), "Calling %TypedArrayPrototype%.indexOf where fromIndex < 0 acts as indexed from the back"); |
| assert.areEqual(5, indexOfFn.call(getTypedArray(), 5, -5), "Calling %TypedArrayPrototype%.indexOf where fromIndex < 0 acts as indexed from the back"); |
| |
| // If we use Array.prototype.indexOf but pass TypedArray objects, make sure the property named length is used instead of the internal TypedArray length slot |
| var u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 0 }); |
| assert.areEqual(-1, Array.prototype.indexOf.call(u, 0), "Calling Array.prototype.indexOf where length is zero returns -1"); |
| var u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 5 }); |
| assert.areEqual(-1, Array.prototype.indexOf.call(u, 6), "Calling Array.prototype.indexOf with a TypedArray that lies about length - make sure we don't actually find the element"); |
| |
| assert.throws(function() { indexOfFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.indexOf with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { indexOfFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.indexOf with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { indexOfFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.indexOf with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.includes behavior", |
| body: function() { |
| var includesFn = Int8Array.prototype.__proto__.includes; |
| |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| assert.isFalse(includesFn.call(getTypedArray(), undefined), "Calling %TypedArrayPrototype%.includes with undefined returns true"); |
| assert.isTrue(includesFn.call(getTypedArray(), 0), "Calling %TypedArrayPrototype%.includes searching for the first value"); |
| assert.isTrue(includesFn.call(getTypedArray(), 9), "Calling %TypedArrayPrototype%.includes searching for the last value"); |
| assert.isFalse(includesFn.call(getTypedArray(), 0, 1), "Calling %TypedArrayPrototype%.includes searching for the first value but skipping the first element returns false"); |
| assert.isFalse(includesFn.call(getTypedArray(), 0, 11), "Calling %TypedArrayPrototype%.includes where fromIndex > length returns false"); |
| assert.isTrue(includesFn.call(getTypedArray(), 0, -10), "Calling %TypedArrayPrototype%.includes where fromIndex < 0 acts as indexed from the back"); |
| assert.isTrue(includesFn.call(getTypedArray(), 5, -5), "Calling %TypedArrayPrototype%.includes where fromIndex < 0 acts as indexed from the back"); |
| |
| // If we use Array.prototype.includes but pass TypedArray objects, make sure the property named length is used instead of the internal TypedArray length slot |
| var u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 0 }); |
| assert.isFalse(Array.prototype.includes.call(u, 0), "Calling Array.prototype.includes where length is zero returns false"); |
| var u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 5 }); |
| assert.isFalse(Array.prototype.includes.call(u, 6), "Calling Array.prototype.includes with a TypedArray that lies about length - make sure we don't actually find the element"); |
| |
| assert.throws(function() { includesFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.includes with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { includesFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.includes with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { includesFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.includes with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.lastIndexOf behavior", |
| body: function() { |
| var lastIndexOf = Int8Array.prototype.__proto__.lastIndexOf; |
| |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual(-1, lastIndexOf.call(getTypedArray(), undefined), "Calling %TypedArrayPrototype%.lastIndexOf with undefined returns -1"); |
| assert.areEqual(0, lastIndexOf.call(getTypedArray(), 0), "Calling %TypedArrayPrototype%.lastIndexOf searching for the first value"); |
| assert.areEqual(9, lastIndexOf.call(getTypedArray(), 9), "Calling %TypedArrayPrototype%.lastIndexOf searching for the last value"); |
| assert.areEqual(-1, lastIndexOf.call(getTypedArray(), 9, -2), "Calling %TypedArrayPrototype%.lastIndexOf searching for the last value but skipping the last element returns -1"); |
| assert.areEqual(-1, lastIndexOf.call(getTypedArray(), 4, 2), "Calling %TypedArrayPrototype%.lastIndexOf where fromIndex < the searched element returns -1"); |
| assert.areEqual(0, lastIndexOf.call(getTypedArray(), 0, -10), "Calling %TypedArrayPrototype%.lastIndexOf where fromIndex < 0 acts as indexed from the back"); |
| assert.areEqual(5, lastIndexOf.call(getTypedArray(), 5, -5), "Calling %TypedArrayPrototype%.lastIndexOf where fromIndex < 0 acts as indexed from the back"); |
| |
| var u = getTypedArray(); |
| u[3] = 2; |
| u[4] = 2; |
| u[5] = 2; |
| assert.areEqual(5, lastIndexOf.call(u, 2), "%TypedArrayPrototype%.lastIndexOf with array that repeats values returns the last index of the value"); |
| |
| Object.defineProperty(u, 'length', { value: 4 }); |
| assert.areEqual(3, Array.prototype.lastIndexOf.call(u, 2), "Calling Array.prototype.lastIndexOf where TypedArray contains more instances of search element beyond length"); |
| |
| var u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 0 }); |
| assert.areEqual(-1, Array.prototype.lastIndexOf.call(u, 0), "Calling Array.prototype.lastIndexOf where length is zero returns -1"); |
| |
| assert.throws(function() { lastIndexOf.call(); }, TypeError, "Calling %TypedArrayPrototype%.lastIndexOf with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { lastIndexOf.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.lastIndexOf with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { lastIndexOf.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.lastIndexOf with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.reverse behavior", |
| body: function() { |
| var reverse = Int8Array.prototype.__proto__.reverse; |
| |
| function getTypedArray() { |
| var t = new Int8Array(10); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual([9,8,7,6,5,4,3,2,1,0], reverse.call(getTypedArray()), "Calling %TypedArrayPrototype%.reverse with basic behavior"); |
| |
| var u = getTypedArray(); |
| assert.areEqual(u, reverse.call(u), "Calling %TypedArrayPrototype%.reverse returns the correct object"); |
| assert.isTrue(u === reverse.call(u), "Calling %TypedArrayPrototype%.reverse returns the correct object"); |
| |
| var u = new Uint8Array(3); |
| u[0] = 1; |
| u[1] = 2; |
| u[2] = 3; |
| assert.areEqual([3,2,1], reverse.call(u), "Calling %TypedArrayPrototype%.reverse with an odd-length TypedArray"); |
| |
| var u = new Uint8Array(1); |
| u[0] = 1; |
| assert.areEqual([1], reverse.call(u), "Calling %TypedArrayPrototype%.reverse with TypedArray of length == 1"); |
| |
| var u = new Uint8Array(0); |
| assert.areEqual([], reverse.call(u), "Calling %TypedArrayPrototype%.reverse with TypedArray of length == 0"); |
| |
| // Call Array.prototype.reverse passing a TypedArray that lies about length. We should only reverse the part of it less than the indicated length. |
| u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 5 }); |
| assert.areEqual([4,3,2,1,0,5,6,7,8,9], Array.prototype.reverse.call(u), "Calling %TypedArrayPrototype%.reverse with a TypedArray that lies about length"); |
| |
| // Call Array.prototype.reverse passing a TypedArray that lies about length. TypedArrays do not support delete so we will throw if indicated length is longer than actual. |
| u = getTypedArray(); |
| Object.defineProperty(u, 'length', { value: 20 }); |
| assert.throws(function() { Array.prototype.reverse.call(u); }, TypeError, "Calling %TypedArrayPrototype%.reverse with a TypedArray that says it has longer length than actual throws", "Object doesn't support this action"); |
| |
| assert.throws(function() { reverse.call(); }, TypeError, "Calling %TypedArrayPrototype%.reverse with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reverse.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.reverse with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reverse.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.reverse with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.slice behavior", |
| body: function() { |
| var slice = Int8Array.prototype.__proto__.slice; |
| |
| function getTypedArray(n) { |
| var t = new Int8Array(n); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| var u = getTypedArray(10); |
| |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], slice.call(u), "%TypedArrayPrototype%.slice basic functionality"); |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], slice.call(u, 0), "%TypedArrayPrototype%.slice basic functionality"); |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], slice.call(u, undefined), "%TypedArrayPrototype%.slice basic functionality"); |
| assert.areEqual([5,6,7,8,9], slice.call(u, 5), "%TypedArrayPrototype%.slice skipping the first 5 elements"); |
| assert.areEqual([8,9], slice.call(u, -2), "%TypedArrayPrototype%.slice using a negative start index takes only the last elements"); |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], slice.call(u, -100), "%TypedArrayPrototype%.slice has the start index clamped to zero"); |
| assert.areEqual([], slice.call(u, 100), "%TypedArrayPrototype%.slice with start index > length returns empty array"); |
| |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], slice.call(u, 0, 50), "%TypedArrayPrototype%.slice has the end index clamped to length"); |
| assert.areEqual([0,1], slice.call(u, 0, 2), "%TypedArrayPrototype%.slice selecting the first two items"); |
| assert.areEqual([8,9], slice.call(u, 8, 10), "%TypedArrayPrototype%.slice selecting the last two items"); |
| assert.areEqual([6,7,8], slice.call(u, 6, -1), "%TypedArrayPrototype%.slice selecting from index 6 until one before the last"); |
| assert.areEqual([6,7,8], slice.call(u, -4, -1), "%TypedArrayPrototype%.slice selecting from index 6 until one before the last"); |
| assert.areEqual([5], slice.call(u, 5, 6), "%TypedArrayPrototype%.slice selecting a single item from index 5"); |
| |
| assert.areEqual([], slice.call(u, 5, 2), "%TypedArrayPrototype%.slice returns empty array if end < start index"); |
| assert.areEqual([], slice.call(u, 100, 2), "%TypedArrayPrototype%.slice returns empty array if end < start index"); |
| assert.areEqual([], slice.call(u, 100, -100), "%TypedArrayPrototype%.slice returns empty array if end < start index"); |
| |
| var r = u.slice(); |
| assert.isTrue(u !== r, "%TypedArrayPrototype%.slice returns a new object instead of altering the source object"); |
| assert.isTrue(ArrayBuffer.isView(r), "%TypedArrayPrototype%.slice returns a TypedArray object"); |
| assert.areEqual(u[Symbol.toStringTag], r[Symbol.toStringTag], "%TypedArrayPrototype%.slice returns the same type of TypedArray as the source object"); |
| |
| u.constructor = Float32Array; |
| var r = u.slice(); |
| assert.isTrue(ArrayBuffer.isView(r), "%TypedArrayPrototype%.slice returns a TypedArray object"); |
| assert.areEqual("Float32Array", r[Symbol.toStringTag], "%TypedArrayPrototype%.slice returns the same type of TypedArray as the source object's constructor property"); |
| |
| u.constructor = String; |
| var r = u.slice(); |
| assert.isTrue(ArrayBuffer.isView(r), "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is not a TypedArray constructor"); |
| assert.areEqual(0, r[0], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(1, r[1], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(2, r[2], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(3, r[3], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(8, r[8], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(9, r[9], "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| assert.areEqual(10, r.length, "With [@@species], %TypedArrayPrototype%.slice returns a TypedArray object even when source constructor property is String"); |
| |
| u.constructor = Array; |
| assert.throws(function () { u.slice() }, TypeError, "Calling %TypedArrayPrototype%.slice with a constructor property with [@@species] pointing to a non-typed-array constructor throws"); |
| |
| assert.throws(function() { slice.call(); }, TypeError, "Calling %TypedArrayPrototype%.slice without this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { slice.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.slice with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { slice.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.slice with non-object this throws TypeError", "'this' is not a typed array object"); |
| |
| u.constructor = Math.sin; |
| assert.doesNotThrow(function() { slice.call(u); }, "Calling %TypedArrayPrototype%.slice with constructor property pointing to a non-constructor function can still function through [@@species]"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.sort behavior", |
| body: function() { |
| var sort = Int8Array.prototype.__proto__.sort; |
| |
| function getTypedArray(n) { |
| var t = new Int8Array(n); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = n-i; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], getTypedArray(10).sort(), "%TypedArrayPrototype%.sort basic behavior"); |
| assert.areEqual([], getTypedArray(0).sort(), "%TypedArrayPrototype%.sort returns empty array when this arg is empty"); |
| assert.areEqual([1], getTypedArray(1).sort(), "%TypedArrayPrototype%.sort returns the same array for a single-length array"); |
| assert.areEqual([1,2], getTypedArray(2).sort(), "%TypedArrayPrototype%.sort returns the correct value for an array with length == 2"); |
| |
| var u = new Uint8Array(6); |
| u[0] = 200; |
| u[1] = 150; |
| u[2] = u[3] = u[4] = 100; |
| u[5] = 0; |
| assert.areEqual([0,100,100,100,150,200], u.sort(), "%TypedArrayPrototype%.sort sorts multiple elements with the same value"); |
| |
| var f = new Float64Array(5); |
| f[0] = 100.0; |
| f[1] = 99.999999999999; |
| f[2] = 99.9999; |
| f[3] = 99.99999; |
| f[4] = 99.9999; |
| assert.areEqual([99.9999,99.9999,99.99999,99.999999999999,100], f.sort(), "%TypedArrayPrototype%.sort basic behavior with 64-bit floats"); |
| |
| function sortCallbackReverse(x, y) { |
| if (x < y) { |
| return 1; |
| } else if (x > y) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| function sortCallback(x, y) { |
| if (x < y) { |
| return -1; |
| } else if (x > y) { |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| function sortCallbackHate5(x, y) { |
| if (x == 5) { |
| return -1; |
| } |
| if (y == 5) { |
| return 1; |
| } |
| return sortCallback(x, y); |
| } |
| |
| function sortCallbackMalformed(x, y) { |
| switch(x) { |
| case 1: |
| return 0; |
| case 2: |
| return -10.5; |
| case 3: |
| return 'a string'; |
| case 4: |
| return { foo: 'another string' }; |
| case 5: |
| return function foo() { return 90; }; |
| case 6: |
| return 12.99999999999; |
| } |
| |
| return undefined; |
| } |
| |
| assert.areEqual([1,2,3,4,5,6,7,8,9,10], getTypedArray(10).sort(sortCallback), "%TypedArrayPrototype%.sort basic behavior with a non-lying sort callback"); |
| assert.areEqual([10,9,8,7,6,5,4,3,2,1], getTypedArray(10).sort(sortCallbackReverse), "%TypedArrayPrototype%.sort with a sort callback function which reverses elements"); |
| assert.areEqual([5,1,2,3,4,6,7,8,9,10], getTypedArray(10).sort(sortCallbackHate5), "%TypedArrayPrototype%.sort basic behavior with a lying sort callback which hates the number 5"); |
| assert.areEqual([9,8,7,2,10,5,4,3,1,6], getTypedArray(10).sort(sortCallbackMalformed), "%TypedArrayPrototype%.sort basic behavior with a sort callback which returns random values"); |
| |
| assert.throws(function() { sort.call(); }, TypeError, "Calling %TypedArrayPrototype%.sort with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { sort.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.sort with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { sort.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.sort with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { sort.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.sort with non-function callback function throws TypeError", "[TypedArray].prototype.sort: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.find behavior", |
| body: function() { |
| var findFn = Int8Array.prototype.__proto__.find; |
| var thisArg = 'value'; |
| var t; |
| var counter; |
| |
| function getTypedArray(n) { |
| // Also remember t for use in verifying in the callback |
| t = new Int8Array(n); |
| |
| // Reset counter |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function assertCallbackBehavior(val, k, arr, _that) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.find callback called on elements in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.find callback called with correct values"); |
| assert.areEqual(Object(thisArg), _that, "%TypedArrayPrototype%.find callback function should receive the correct this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.find callback called with the correct array arg"); |
| } |
| |
| var expectedValue = 5; |
| function callbackFalseOnExpectedValue(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| if (expectedValue === val) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function callbackAlwaysFalse(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return false; |
| } |
| |
| assert.areEqual(undefined, findFn.call(getTypedArray(10), callbackAlwaysFalse, thisArg), "%TypedArrayPrototype%.find returns undefined when the callback always returns false"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.find calls the callback function the correct number of times"); |
| |
| assert.areEqual(expectedValue, findFn.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.find returns the value of the array which causes the callback to return true"); |
| assert.areEqual(6, counter, "%TypedArrayPrototype%.find calls the callback function the correct number of times"); |
| |
| expectedValue = 0; |
| assert.areEqual(expectedValue, findFn.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.find returns the value of the array which causes the callback to return true"); |
| assert.areEqual(1, counter, "%TypedArrayPrototype%.find calls the callback function the correct number of times"); |
| |
| expectedValue = 9; |
| assert.areEqual(expectedValue, findFn.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.find returns the value of the array which causes the callback to return true"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.find calls the callback function the correct number of times"); |
| |
| assert.throws(function() { findFn.call(); }, TypeError, "Calling %TypedArrayPrototype%.find with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findFn.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.find with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findFn.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.find with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findFn.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.find with no callback function throws TypeError", "[TypedArray].prototype.find: argument is not a Function object"); |
| assert.throws(function() { findFn.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.find with undefined callback function throws TypeError", "[TypedArray].prototype.find: argument is not a Function object"); |
| assert.throws(function() { findFn.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.find with non-function callback function throws TypeError", "[TypedArray].prototype.find: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.findIndex behavior", |
| body: function() { |
| var findIndex = Int8Array.prototype.__proto__.findIndex; |
| var thisArg = 'value'; |
| var t; |
| var counter; |
| |
| function getTypedArray(n) { |
| // Also remember t for use in verifying in the callback |
| t = new Int8Array(n); |
| |
| // Reset counter |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function assertCallbackBehavior(val, k, arr, _that) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.findIndex callback called on elements in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.findIndex callback called with correct values"); |
| assert.areEqual(Object(thisArg), _that, "%TypedArrayPrototype%.findIndex callback function should receive the correct this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.findIndex callback called with the correct array arg"); |
| } |
| |
| var expectedValue = 5; |
| function callbackFalseOnExpectedValue(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| if (expectedValue === val) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function callbackAlwaysFalse(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return false; |
| } |
| |
| assert.areEqual(-1, findIndex.call(getTypedArray(10), callbackAlwaysFalse, thisArg), "%TypedArrayPrototype%.findIndex returns -1 when the callback always returns false"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.findIndex calls the callback function the correct number of times"); |
| |
| assert.areEqual(expectedValue, findIndex.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.findIndex returns the index of the element of the array which causes the callback to return true"); |
| assert.areEqual(6, counter, "%TypedArrayPrototype%.findIndex calls the callback function the correct number of times"); |
| |
| expectedValue = 0; |
| assert.areEqual(expectedValue, findIndex.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.findIndex returns the index of the element of the array which causes the callback to return true"); |
| assert.areEqual(1, counter, "%TypedArrayPrototype%.findIndex calls the callback function the correct number of times"); |
| |
| expectedValue = 9; |
| assert.areEqual(expectedValue, findIndex.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.findIndex returns the index of the element of the array which causes the callback to return true"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.findIndex calls the callback function the correct number of times"); |
| |
| assert.throws(function() { findIndex.call(); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findIndex.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findIndex.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { findIndex.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with no callback function throws TypeError", "[TypedArray].prototype.findIndex: argument is not a Function object"); |
| assert.throws(function() { findIndex.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with undefined callback function throws TypeError", "[TypedArray].prototype.findIndex: argument is not a Function object"); |
| assert.throws(function() { findIndex.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.findIndex with non-function callback function throws TypeError", "[TypedArray].prototype.findIndex: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.filter behavior", |
| body: function() { |
| var filter = Int8Array.prototype.__proto__.filter; |
| var thisArg = 'value'; |
| var t; |
| var counter; |
| |
| function getTypedArray(n) { |
| // Also remember t for use in verifying in the callback |
| t = new Int8Array(n); |
| |
| // Reset counter |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function assertCallbackBehavior(val, k, arr, _that) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.filter callback called on elements in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.filter callback called with correct values"); |
| assert.areEqual(Object(thisArg), _that, "%TypedArrayPrototype%.filter callback function should receive the correct this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.filter callback called with the correct array arg"); |
| } |
| |
| function selectOddNumbers(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| if (val % 2 != 0) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function selectNone(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return false; |
| } |
| |
| function selectAll(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return true; |
| } |
| |
| var counter = 0; |
| var res = filter.call(getTypedArray(10), selectOddNumbers, thisArg); |
| assert.areEqual([1,3,5,7,9], res, "%TypedArrayPrototype%.filter returns a new TypedArray with the right values"); |
| assert.isTrue(ArrayBuffer.isView(res), "%TypedArrayPrototype%.filter returns a new TypedArray"); |
| assert.areEqual("Int8Array", res[Symbol.toStringTag], "%TypedArrayPrototype%.filter returns the right type of new TypedArray"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.filter calls the callback function the correct number of times"); |
| |
| assert.areEqual([], filter.call(getTypedArray(10), selectNone, thisArg), "%TypedArrayPrototype%.filter returns an empty array when callback selects no elements"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.filter calls the callback function the correct number of times"); |
| |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], filter.call(getTypedArray(10), selectAll, thisArg), "%TypedArrayPrototype%.filter returns the original array when callback selects all elements"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.filter calls the callback function the correct number of times"); |
| |
| var u = getTypedArray(10); |
| u.constructor = Int16Array; |
| counter = 0; |
| var res = filter.call(u, selectOddNumbers, thisArg); |
| assert.areEqual([1,3,5,7,9], res, "%TypedArrayPrototype%.filter returns a new array with the right values"); |
| assert.isTrue(ArrayBuffer.isView(res) && res instanceof Int16Array, "%TypedArrayPrototype%.filter returns a typed array if the TypedArray constructor property is changed to a different typed array"); |
| assert.areEqual("Int16Array", res[Symbol.toStringTag], "%TypedArrayPrototype%.filter return value doesn't have @@toStringTag value"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.filter calls the callback function the correct number of times"); |
| |
| u.constructor = Math.sin; |
| counter = 0; |
| assert.doesNotThrow(function() { filter.call(u, selectOddNumbers, thisArg); }, "Calling %TypedArrayPrototype%.filter with constructor property pointing to a non-constructor function can still function through [@@species]"); |
| |
| assert.throws(function() { filter.call(); }, TypeError, "Calling %TypedArrayPrototype%.filter with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { filter.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.filter with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { filter.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.filter with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { filter.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.filter with no callback function throws TypeError", "[TypedArray].prototype.filter: argument is not a Function object"); |
| assert.throws(function() { filter.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.filter with undefined callback function throws TypeError", "[TypedArray].prototype.filter: argument is not a Function object"); |
| assert.throws(function() { filter.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.filter with non-function callback function throws TypeError", "[TypedArray].prototype.filter: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.every behavior", |
| body: function() { |
| var every = Int8Array.prototype.__proto__.every; |
| var thisArg = 'value'; |
| var t; |
| var counter; |
| |
| function getTypedArray(n) { |
| // Also remember t for use in verifying in the callback |
| t = new Int8Array(n); |
| |
| // Reset counter |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function assertCallbackBehavior(val, k, arr, _that) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.every callback called on elements in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.every callback called with correct values"); |
| assert.areEqual(Object(thisArg), _that, "%TypedArrayPrototype%.every callback function should receive the correct this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.every callback called with the correct array arg"); |
| } |
| |
| var expectedValue = 5; |
| function callbackFalseOnExpectedValue(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| if (expectedValue === val) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| function callbackAlwaysTrue(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return true; |
| } |
| |
| assert.isTrue(every.call(getTypedArray(10), callbackAlwaysTrue, thisArg), "%TypedArrayPrototype%.every returns true when the callback always returns true"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.every calls the callback function the correct number of times"); |
| |
| assert.isFalse(every.call(getTypedArray(10), callbackFalseOnExpectedValue, thisArg), "%TypedArrayPrototype%.every returns false if the callback ever returns false"); |
| assert.areEqual(6, counter, "%TypedArrayPrototype%.every calls the callback function the correct number of times"); |
| |
| assert.throws(function() { every.call(); }, TypeError, "Calling %TypedArrayPrototype%.every with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { every.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.every with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { every.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.every with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { every.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.every with no callback function throws TypeError", "[TypedArray].prototype.every: argument is not a Function object"); |
| assert.throws(function() { every.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.every with undefined callback function throws TypeError", "[TypedArray].prototype.every: argument is not a Function object"); |
| assert.throws(function() { every.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.every with non-function callback function throws TypeError", "[TypedArray].prototype.every: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.some behavior", |
| body: function() { |
| var some = Int8Array.prototype.__proto__.some; |
| var thisArg = 'value'; |
| var t; |
| var counter; |
| |
| function getTypedArray(n) { |
| // Also remember t for use in verifying in the callback |
| t = new Int8Array(n); |
| |
| // Reset counter |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function assertCallbackBehavior(val, k, arr, _that) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.some callback called on elements in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.some callback called with correct values"); |
| assert.areEqual(Object(thisArg), _that, "%TypedArrayPrototype%.some callback function should receive the correct this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.some callback called with the correct array arg"); |
| } |
| |
| var expectedValue = 5; |
| function callbackTrueOnExpectedValue(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| if (expectedValue === val) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function callbackAlwaysFalse(val, k, arr) { |
| assertCallbackBehavior(val, k, arr, this); |
| |
| counter++; |
| |
| return false; |
| } |
| |
| assert.isFalse(some.call(getTypedArray(10), callbackAlwaysFalse, thisArg), "%TypedArrayPrototype%.some returns false when the callback always returns false"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.some calls the callback function the correct number of times"); |
| |
| assert.isTrue(some.call(getTypedArray(10), callbackTrueOnExpectedValue, thisArg), "%TypedArrayPrototype%.some returns true if the callback ever returns true"); |
| assert.areEqual(6, counter, "%TypedArrayPrototype%.some calls the callback function the correct number of times"); |
| |
| assert.throws(function() { some.call(); }, TypeError, "Calling %TypedArrayPrototype%.some with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { some.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.some with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { some.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.some with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { some.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.some with no callback function throws TypeError", "[TypedArray].prototype.some: argument is not a Function object"); |
| assert.throws(function() { some.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.some with undefined callback function throws TypeError", "[TypedArray].prototype.some: argument is not a Function object"); |
| assert.throws(function() { some.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.some with non-function callback function throws TypeError", "[TypedArray].prototype.some: argument is not a Function object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.join behavior", |
| body: function() { |
| var join = Int8Array.prototype.__proto__.join; |
| |
| function getTypedArray(n) { |
| var t = new Int8Array(n); |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i+1; |
| } |
| |
| return t; |
| } |
| |
| assert.areEqual('1,2,3,4,5,6,7,8,9,10', join.call(getTypedArray(10)), "%TypedArrayPrototype%.join basic behavior"); |
| assert.areEqual('', join.call(getTypedArray(0)), "%TypedArrayPrototype%.join called with zero-length TypedArray"); |
| assert.areEqual('1', join.call(getTypedArray(1)), "%TypedArrayPrototype%.join called with single-length TypedArray"); |
| assert.areEqual('1,2', join.call(getTypedArray(2)), "%TypedArrayPrototype%.join called with length == 2 TypedArray"); |
| assert.areEqual('1,2,3', join.call(getTypedArray(3)), "%TypedArrayPrototype%.join called with length == 3 TypedArray"); |
| |
| assert.throws(function() { join.call(); }, TypeError, "Calling %TypedArrayPrototype%.join with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { join.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.join with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { join.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.join with non-object this throws TypeError", "'this' is not a typed array object"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.reduce behavior", |
| body: function() { |
| var reduce = Int8Array.prototype.__proto__.reduce; |
| var t; |
| var counter; |
| var thisArg = Object(this); |
| |
| function getTypedArray(n) { |
| t = new Int8Array(n); |
| counter = 0; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function sumItemsCallback(accumulator, val, k, arr) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.reduce calls the callback on items in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.reduce calls the callback with the correct values"); |
| assert.areEqual(thisArg, this, "%TypedArrayPrototype%.reduce calls the callback with undefined as the this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.reduce calls the callback with the correct array object"); |
| |
| counter++; |
| |
| return accumulator + val; |
| } |
| |
| assert.areEqual(45, reduce.call(getTypedArray(10), sumItemsCallback, 0), "%TypedArrayPrototype%.reduce basic functionality"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.reduce called the callback the correct number of times"); |
| assert.areEqual(100, reduce.call(getTypedArray(0), sumItemsCallback, 100), "%TypedArrayPrototype%.reduce with a zero-length array returns the initial value"); |
| assert.areEqual(0, counter, "%TypedArrayPrototype%.reduce didn't call the callback on an empty array"); |
| |
| var u = getTypedArray(10); |
| counter = 1; |
| assert.areEqual(45, reduce.call(u, sumItemsCallback), "%TypedArrayPrototype%.reduce called with no initial value causes the first index passed to the callback to be shifted by one"); |
| assert.areEqual(10, counter, "%TypedArrayPrototype%.reduce called the callback the correct number of times"); |
| |
| assert.throws(function() { reduce.call(); }, TypeError, "Calling %TypedArrayPrototype%.reduce with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduce.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.reduce with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduce.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.reduce with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduce.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.reduce with no callback function throws TypeError", "[TypedArray].prototype.reduce: argument is not a Function object"); |
| assert.throws(function() { reduce.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.reduce with undefined callback function throws TypeError", "[TypedArray].prototype.reduce: argument is not a Function object"); |
| assert.throws(function() { reduce.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.reduce with non-function callback function throws TypeError", "[TypedArray].prototype.reduce: argument is not a Function object"); |
| assert.throws(function() { reduce.call(getTypedArray(0), sumItemsCallback); }, TypeError, "%TypedArrayPrototype%.reduce throws if array has zero length"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.reduceRight behavior", |
| body: function() { |
| var reduceRight = Int8Array.prototype.__proto__.reduceRight; |
| var t; |
| var counter; |
| var thisArg = Object(this); |
| |
| function getTypedArray(n) { |
| t = new Int8Array(n); |
| |
| // counter starts at the end for reduceRight (last index == n-1) |
| counter = n-1; |
| |
| for(var i = 0; i < t.length; i++) { |
| t[i] = i; |
| } |
| |
| return t; |
| } |
| |
| function sumItemsCallback(accumulator, val, k, arr) { |
| assert.areEqual(counter, k, "%TypedArrayPrototype%.reduceRight calls the callback on items in order"); |
| assert.areEqual(val, k, "%TypedArrayPrototype%.reduceRight calls the callback with the correct values"); |
| assert.areEqual(thisArg, this, "%TypedArrayPrototype%.reduceRight calls the callback with undefined as the this arg"); |
| assert.areEqual(t, arr, "%TypedArrayPrototype%.reduceRight calls the callback with the correct array object"); |
| |
| counter--; |
| |
| return accumulator + val; |
| } |
| |
| assert.areEqual(45, reduceRight.call(getTypedArray(10), sumItemsCallback, 0), "%TypedArrayPrototype%.reduceRight basic functionality"); |
| assert.areEqual(-1, counter, "%TypedArrayPrototype%.reduceRight called the callback the correct number of times"); |
| assert.areEqual(100, reduceRight.call(getTypedArray(0), sumItemsCallback, 100), "%TypedArrayPrototype%.reduceRight with a zero-length array returns the initial value"); |
| assert.areEqual(-1, counter, "%TypedArrayPrototype%.reduceRight didn't call the callback on an empty array"); |
| |
| var u = getTypedArray(10); |
| counter = 8; // second-to-last index |
| assert.areEqual(45, reduceRight.call(u, sumItemsCallback), "%TypedArrayPrototype%.reduceRight called with no initial value causes the first index passed to the callback to be shifted by one"); |
| assert.areEqual(-1, counter, "%TypedArrayPrototype%.reduceRight called the callback the correct number of times"); |
| |
| assert.throws(function() { reduceRight.call(); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with no this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduceRight.call(undefined); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with undefined this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduceRight.call('string'); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with non-object this throws TypeError", "'this' is not a typed array object"); |
| assert.throws(function() { reduceRight.call(new Uint8Array(10)); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with no callback function throws TypeError", "[TypedArray].prototype.reduceRight: argument is not a Function object"); |
| assert.throws(function() { reduceRight.call(new Uint8Array(10), undefined); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with undefined callback function throws TypeError", "[TypedArray].prototype.reduceRight: argument is not a Function object"); |
| assert.throws(function() { reduceRight.call(new Uint8Array(10), 'string'); }, TypeError, "Calling %TypedArrayPrototype%.reduceRight with non-function callback function throws TypeError", "[TypedArray].prototype.reduceRight: argument is not a Function object"); |
| assert.throws(function() { reduceRight.call(getTypedArray(0), sumItemsCallback); }, TypeError, "%TypedArrayPrototype%.reduceRight throws if array has zero length"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.isView API shape verification", |
| body: function() { |
| assert.isFalse(ArrayBuffer.isView === undefined, "ArrayBuffer.isView !== undefined"); |
| assert.areEqual('function', typeof ArrayBuffer.isView, "typeof ArrayBuffer.isView == 'function'"); |
| assert.areEqual(1, ArrayBuffer.isView.length, "ArrayBuffer.isView.length == 1"); |
| |
| var descriptor = Object.getOwnPropertyDescriptor(ArrayBuffer, 'isView'); |
| |
| assert.isTrue(descriptor.writable, "ArrayBuffer.isView.writable === true"); |
| assert.isFalse(descriptor.enumerable, "ArrayBuffer.isView.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "ArrayBuffer.isView.configurable === true"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.isView behavior", |
| body: function() { |
| // All of the TypedArray prototypes should be ordinary objects and should return false when passed to ArrayBuffer.isView. |
| assert.isFalse(ArrayBuffer.isView(ArrayBuffer.prototype), "ArrayBuffer.isView(ArrayBuffer.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(DataView.prototype), "ArrayBuffer.isView(DataView.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Uint8Array.prototype), "ArrayBuffer.isView(Uint8Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Uint16Array.prototype), "ArrayBuffer.isView(Uint16Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Uint32Array.prototype), "ArrayBuffer.isView(Uint32Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Int8Array.prototype), "ArrayBuffer.isView(Int8Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Int16Array.prototype), "ArrayBuffer.isView(Int16Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Int32Array.prototype), "ArrayBuffer.isView(Int32Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Uint8ClampedArray.prototype), "ArrayBuffer.isView(Uint8ClampedArray.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Float32Array.prototype), "ArrayBuffer.isView(Float32Array.prototype) === false"); |
| assert.isFalse(ArrayBuffer.isView(Float64Array.prototype), "ArrayBuffer.isView(Float64Array.prototype) === false"); |
| |
| assert.isTrue(ArrayBuffer.isView(new DataView(new ArrayBuffer(20))), "ArrayBuffer.isView(new DataView(new ArrayBuffer(20))) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Uint8Array(10)), "ArrayBuffer.isView(new Uint8Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Uint16Array(10)), "ArrayBuffer.isView(new Uint16Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Uint32Array(10)), "ArrayBuffer.isView(new Uint32Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Int8Array(10)), "ArrayBuffer.isView(new Int8Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Int16Array(10)), "ArrayBuffer.isView(new Int16Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Int32Array(10)), "ArrayBuffer.isView(new Int32Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Uint8ClampedArray(10)), "ArrayBuffer.isView(new Uint8ClampedArray(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Float32Array(10)), "ArrayBuffer.isView(new Float32Array(10)) === true"); |
| assert.isTrue(ArrayBuffer.isView(new Float64Array(10)), "ArrayBuffer.isView(new Float64Array(10)) === true"); |
| |
| assert.isFalse(ArrayBuffer.isView(undefined), "ArrayBuffer.isView(undefined) === false"); |
| assert.isFalse(ArrayBuffer.isView(null), "ArrayBuffer.isView(null) === false"); |
| assert.isFalse(ArrayBuffer.isView(), "ArrayBuffer.isView() === false"); |
| assert.isFalse(ArrayBuffer.isView(new ArrayBuffer(20)), "ArrayBuffer.isView(new ArrayBuffer(20)) === false"); |
| assert.isFalse(ArrayBuffer.isView({buffer:[0,1,2],byteLength:12,byteOffset:0}), "ArrayBuffer.isView({buffer:[0,1,2],byteLength:12,byteOffset:0}) === false"); |
| assert.isFalse(ArrayBuffer.isView([1,2,3]), "ArrayBuffer.isView([1,2,3]) === false"); |
| assert.isFalse(ArrayBuffer.isView(true), "ArrayBuffer.isView(true) === false"); |
| assert.isFalse(ArrayBuffer.isView(false), "ArrayBuffer.isView(false) === false"); |
| assert.isFalse(ArrayBuffer.isView(0), "ArrayBuffer.isView(0) === false"); |
| assert.isFalse(ArrayBuffer.isView(1), "ArrayBuffer.isView(1) === false"); |
| assert.isFalse(ArrayBuffer.isView(1.0), "ArrayBuffer.isView(1.0) === false"); |
| assert.isFalse(ArrayBuffer.isView('string'), "ArrayBuffer.isView('string') === false"); |
| assert.isFalse(ArrayBuffer.isView({}), "ArrayBuffer.isView({}) === false"); |
| assert.isFalse(ArrayBuffer.isView(function() {}), "ArrayBuffer.isView(function() {}) === false"); |
| assert.isFalse(ArrayBuffer.isView(new Array(1)), "ArrayBuffer.isView(new Array(1)) === false"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice API shape verification", |
| body: function() { |
| assert.isFalse(ArrayBuffer.prototype.slice === undefined, "ArrayBuffer.prototype.slice !== undefined"); |
| assert.areEqual('function', typeof ArrayBuffer.prototype.slice, "typeof ArrayBuffer.prototype.slice == 'function'"); |
| assert.areEqual(2, ArrayBuffer.prototype.slice.length, "ArrayBuffer.prototype.slice.length == 2"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice behavior with non-ArrayBuffer parameters", |
| body: function() { |
| assert.throws(function () { ArrayBuffer.prototype.slice.apply('string'); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if this parameter is not an ArrayBuffer", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.slice.apply(); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if there is no this parameter", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.slice.call(); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if it is called directly", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.slice.call(undefined); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if it is called directly", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.slice(); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if it is called directly", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.slice(undefined); }, TypeError, "ArrayBuffer.prototype.slice throws TypeError if it is called directly", "ArrayBuffer object expected"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice behavior with positive start offset", |
| body: function() { |
| var len = 10; |
| var buf = new ArrayBuffer(len); |
| var u8 = new Uint8Array(buf); |
| |
| for (var i = 0; i < u8.length; i++) |
| { |
| u8[i] = i + 1; |
| } |
| |
| var sliced = buf.slice(); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice() returns the same array elements as the original"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice() returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(0); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(0) returns the same array elements as the original"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(0) returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(5); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([6,7,8,9,10], slicedArray, "slice(5) contains the last 5 elements - [6,7,8,9,10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "slice(5) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(9); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([10], slicedArray, "slice(9) contains the last 1 elements - [10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(1, sliced.byteLength, "slice(9) returns an ArrayBuffer with byteLength = 1"); |
| |
| var sliced = buf.slice(10); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(10) contains empty buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(10) returns an ArrayBuffer with byteLength = 0"); |
| |
| var sliced = buf.slice(15); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(15) contains empty buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(15) returns an ArrayBuffer with byteLength = 0"); |
| |
| var sliced = buf.slice(100); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(100) contains empty buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(100) returns an ArrayBuffer with byteLength = 0"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice behavior with negative start offset", |
| body: function() { |
| var len = 10; |
| var buf = new ArrayBuffer(len); |
| var u8 = new Uint8Array(buf); |
| |
| for (var i = 0; i < u8.length; i++) |
| { |
| u8[i] = i + 1; |
| } |
| |
| var sliced = buf.slice(-4); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([7,8,9,10], slicedArray, "slice(-4) returns the last 4 elements - [7,8,9,10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(4, sliced.byteLength, "slice(-4) returns an ArrayBuffer with the byteLength = 4"); |
| |
| var sliced = buf.slice(-5); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([6,7,8,9,10], slicedArray, "slice(-5) contains the last 5 elements - [6,7,8,9,10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "slice(-5) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(-9); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([2,3,4,5,6,7,8,9,10], slicedArray, "slice(-9) contains the last 9 elements - [2,3,4,5,6,7,8,9,10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(9, sliced.byteLength, "slice(-9) returns an ArrayBuffer with byteLength = 9"); |
| |
| var sliced = buf.slice(-10); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(-10) returns ArrayBuffer containing the entire original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(-10) returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(-15); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(-15) returns ArrayBuffer containing the entire original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(-15) returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(-100); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(-100) returns ArrayBuffer containing the entire original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(-100) returns an ArrayBuffer with the same byteLength as the original"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice behavior with positive start offset and positive end offset", |
| body: function() { |
| var len = 10; |
| var buf = new ArrayBuffer(len); |
| var u8 = new Uint8Array(buf); |
| |
| for (var i = 0; i < u8.length; i++) |
| { |
| u8[i] = i + 1; |
| } |
| |
| var sliced = buf.slice(0, len); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(0, len) returns all the elements of the original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(0, len) returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(0, len * 10); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(0, len*10) returns all the elements of the original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(0, len*10) returns an ArrayBuffer with the same byteLength as the original"); |
| |
| var sliced = buf.slice(0, 5); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([1,2,3,4,5], slicedArray, "slice(0, 5) contains the first 5 elements - [1,2,3,4,5]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "slice(0, 5) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(1, 1); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(1, 1) contains no elements - the empty buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(1, 1) returns an ArrayBuffer with byteLength = 0"); |
| |
| var sliced = buf.slice(5, 10); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([6,7,8,9,10], slicedArray, "slice(5, 10) returns the last 5 elements - [6,7,8,9,10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "slice(5, 10) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(9, 10); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([10], slicedArray, "slice(9, 10) returns the last element - [10]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(1, sliced.byteLength, "slice(9, 10) returns an ArrayBuffer with byteLength = 1"); |
| |
| var sliced = buf.slice(7, 5); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(7, 5) returns empty ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(7, 5) returns an ArrayBuffer with byteLength = 0"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice behavior with mix of positive and negative start offset and end offset", |
| body: function() { |
| var len = 10; |
| var buf = new ArrayBuffer(len); |
| var u8 = new Uint8Array(buf); |
| |
| for (var i = 0; i < u8.length; i++) |
| { |
| u8[i] = i + 1; |
| } |
| |
| var sliced = buf.slice(5, -2); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([6,7,8], slicedArray, "slice(5, -2) returns elements 5 through (len-2) = [6,7,8]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(3, sliced.byteLength, "slice(5, -2) returns an ArrayBuffer with byteLength = 3"); |
| |
| var sliced = buf.slice(-5, 8); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([6,7,8], slicedArray, "slice(-5, 8) returns elements 5 through 8 = [6,7,8]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(3, sliced.byteLength, "slice(-5, 8) returns an ArrayBuffer with byteLength = 3"); |
| |
| var sliced = buf.slice(-10, buf.byteLength); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(-10, len) returns elements all the elements of the original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(-10, len) returns an ArrayBuffer the same byteLength as the original"); |
| |
| var sliced = buf.slice(-20, buf.byteLength * 2); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual(u8, slicedArray, "slice(-20, len*2) returns elements all the elements of the original buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(buf.byteLength, sliced.byteLength, "slice(-20, len*2) returns an ArrayBuffer the same byteLength as the original"); |
| |
| var sliced = buf.slice(-7, -3); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([4,5,6,7], slicedArray, "slice(-7, -3) returns elements 3 through (len-3) = [4,5,6,7]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(4, sliced.byteLength, "slice(-7, -3) returns an ArrayBuffer with byteLength = 4"); |
| |
| var sliced = buf.slice(-3, -7); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "slice(-3, -7) returns empty buffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "slice(-3, -7) returns an ArrayBuffer with byteLength = 0"); |
| } |
| }, |
| { |
| name: "DataView.prototype.buffer API shape", |
| body: function() { |
| assert.isTrue(DataView.prototype.hasOwnProperty('buffer'), "ArrayBuffer.prototype.hasOwnProperty('buffer') == true"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer'); |
| |
| assert.isTrue(descriptor !== undefined, "Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer') !== undefined"); |
| |
| assert.isTrue(descriptor.get !== undefined, "DataView.prototype.buffer.get !== undefined"); |
| assert.isTrue(typeof descriptor.get === 'function', "typeof DataView.prototype.buffer.get === 'function'"); |
| assert.areEqual(0, descriptor.get.length, "DataView.prototype.buffer.get.length === 0"); |
| |
| assert.isTrue(descriptor.set === undefined, "DataView.prototype.buffer.set === undefined"); |
| |
| assert.isFalse(descriptor.enumerable, "DataView.prototype.buffer.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "DataView.prototype.buffer.configurable === true"); |
| } |
| }, |
| { |
| name: "DataView.prototype.buffer behavior", |
| body: function() { |
| var buf = new ArrayBuffer(10); |
| var view = new DataView(buf); |
| |
| assert.isTrue(buf === view.buffer, "buffer returns the same ArrayBuffer object passed to DataView constructor"); |
| |
| // Assignment has no effect since view.buffer does not have a setter |
| view.buffer = undefined; |
| assert.isTrue(buf === view.buffer, "Assigning to buffer has no effect"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer'); |
| |
| assert.throws(function () { descriptor.get(); }, TypeError, "DataView.prototype.buffer called with no 'this' argument", "'this' is not a DataView object"); |
| assert.isTrue(buf === descriptor.get.call(view), "Calling getter directly returns expected buffer"); |
| |
| assert.throws(function () { descriptor.get.apply(DataView.prototype) }, TypeError, "Applying getter with DataView.prototype fails", "'this' is not a DataView object"); |
| assert.throws(function () { DataView.prototype.buffer; }, TypeError, "Calling DataView.prototype.buffer fails", "'this' is not a DataView object"); |
| |
| Object.defineProperty(DataView.prototype, "buffer", {value: 'something'}); |
| |
| assert.areEqual('string', typeof DataView.prototype.buffer, "Override DataView.prototype.buffer via Object.defineProperty works"); |
| assert.areEqual('something', DataView.prototype.buffer, "Override DataView.prototype.buffer via Object.defineProperty works"); |
| assert.areEqual('something', view.buffer, "Override DataView.prototype.buffer via Object.defineProperty affects instance objects"); |
| } |
| }, |
| { |
| name: "DataView.prototype.byteOffset API shape", |
| body: function() { |
| assert.isTrue(DataView.prototype.hasOwnProperty('byteOffset'), "ArrayBuffer.prototype.hasOwnProperty('byteOffset') == true"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset'); |
| |
| assert.isTrue(descriptor !== undefined, "Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset') !== undefined"); |
| |
| assert.isTrue(descriptor.get !== undefined, "DataView.prototype.byteOffset.get !== undefined"); |
| assert.isTrue(typeof descriptor.get === 'function', "typeof DataView.prototype.byteOffset.get === 'function'"); |
| assert.areEqual(0, descriptor.get.length, "DataView.prototype.byteOffset.get.length === 0"); |
| |
| assert.isTrue(descriptor.set === undefined, "DataView.prototype.byteOffset.set === undefined"); |
| |
| assert.isFalse(descriptor.enumerable, "DataView.prototype.byteOffset.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "DataView.prototype.byteOffset.configurable === true"); |
| } |
| }, |
| { |
| name: "DataView.prototype.byteOffset behavior", |
| body: function() { |
| var buf = new ArrayBuffer(10); |
| var view = new DataView(buf); |
| |
| assert.areEqual(0, view.byteOffset, "byteOffset returns the same value passed to DataView constructor"); |
| |
| // Assignment has no effect since view.byteOffset does not have a setter |
| view.byteOffset = -1; |
| assert.areEqual(0, view.byteOffset, "Assigning to byteOffset has no effect"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset'); |
| |
| assert.throws(function () { descriptor.get(); }, TypeError, "DataView.prototype.byteOffset called with no 'this' argument", "'this' is not a DataView object"); |
| assert.areEqual(0, descriptor.get.call(view), "Calling getter directly returns expected byteOffset"); |
| |
| assert.throws(function () { descriptor.get.apply(DataView.prototype) }, TypeError, "Applying getter with DataView.prototype fails", "'this' is not a DataView object"); |
| assert.throws(function () { DataView.prototype.byteOffset; }, TypeError, "Calling DataView.prototype.byteOffset fails", "'this' is not a DataView object"); |
| |
| Object.defineProperty(DataView.prototype, "byteOffset", {value: 'something'}); |
| |
| assert.areEqual('string', typeof DataView.prototype.byteOffset, "Override DataView.prototype.byteOffset via Object.defineProperty works"); |
| assert.areEqual('something', DataView.prototype.byteOffset, "Override DataView.prototype.byteOffset via Object.defineProperty works"); |
| assert.areEqual('something', view.byteOffset, "Override DataView.prototype.byteOffset via Object.defineProperty affects instance objects"); |
| } |
| }, |
| { |
| name: "DataView.prototype.byteLength API shape", |
| body: function() { |
| assert.isTrue(DataView.prototype.hasOwnProperty('byteLength'), "ArrayBuffer.prototype.hasOwnProperty('byteLength') == true"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength'); |
| |
| assert.isTrue(descriptor !== undefined, "Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength') !== undefined"); |
| |
| assert.isTrue(descriptor.get !== undefined, "DataView.prototype.byteLength.get !== undefined"); |
| assert.isTrue(typeof descriptor.get === 'function', "typeof DataView.prototype.byteLength.get === 'function'"); |
| assert.areEqual(0, descriptor.get.length, "DataView.prototype.byteLength.get.length === 0"); |
| |
| assert.isTrue(descriptor.set === undefined, "DataView.prototype.byteLength.set === undefined"); |
| |
| assert.isFalse(descriptor.enumerable, "DataView.prototype.byteLength.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "DataView.prototype.byteLength.configurable === true"); |
| } |
| }, |
| { |
| name: "DataView.prototype.byteLength behavior", |
| body: function() { |
| var buf = new ArrayBuffer(10); |
| var view = new DataView(buf); |
| |
| assert.areEqual(10, view.byteLength, "byteLength returns the same value passed to DataView constructor"); |
| |
| // Assignment has no effect since view.byteLength does not have a setter |
| view.byteLength = -1; |
| assert.areEqual(10, view.byteLength, "Assigning to byteLength has no effect"); |
| |
| descriptor = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength'); |
| |
| assert.throws(function () { descriptor.get(); }, TypeError, "DataView.prototype.byteLength called with no 'this' argument", "'this' is not a DataView object"); |
| assert.areEqual(10, descriptor.get.call(view), "Calling getter directly returns expected byteLength"); |
| |
| assert.throws(function () { descriptor.get.apply(DataView.prototype) }, TypeError, "Applying getter with DataView.prototype fails", "'this' is not a DataView object"); |
| assert.throws(function () { DataView.prototype.byteLength; }, TypeError, "Calling DataView.prototype.byteLength fails", "'this' is not a DataView object"); |
| |
| Object.defineProperty(DataView.prototype, "byteLength", {value: 'something'}); |
| |
| assert.areEqual('string', typeof DataView.prototype.byteLength, "Override DataView.prototype.byteLength via Object.defineProperty works"); |
| assert.areEqual('something', DataView.prototype.byteLength, "Override DataView.prototype.byteLength via Object.defineProperty works"); |
| assert.areEqual('something', view.byteLength, "Override DataView.prototype.byteLength via Object.defineProperty affects instance objects"); |
| } |
| }, |
| { |
| name: "BLUE: 519650, 519651, 519652 - ArrayBuffer.prototype.slice behavior with undefined or infinite arguments", |
| body: function() { |
| var len = 5; |
| var buf = new ArrayBuffer(len); |
| var u8 = new Uint8ClampedArray(buf); |
| |
| for (var i = 0; i < u8.length; i++) |
| { |
| u8[i] = i + 1; |
| } |
| |
| var sliced = buf.slice(3, undefined); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([4,5], slicedArray, "slice(3, undefined) returns elements 3 through len-1 = [4,5]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(2, sliced.byteLength, "slice(3, undefined) returns an ArrayBuffer with byteLength = 2"); |
| |
| var sliced = buf.slice(Number.POSITIVE_INFINITY, 3); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "buf.slice(Number.POSITIVE_INFINITY, 3) returns elements an empty ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "buf.slice(Number.POSITIVE_INFINITY, 3) returns an ArrayBuffer with byteLength = 0"); |
| |
| var sliced = buf.slice(2, Number.POSITIVE_INFINITY); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([3,4,5], slicedArray, "buf.slice(2, Number.POSITIVE_INFINITY) returns elements 2 through len-1 = [3,4,5]"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(3, sliced.byteLength, "buf.slice(2, Number.POSITIVE_INFINITY) returns an ArrayBuffer with byteLength = 3"); |
| |
| var sliced = buf.slice(NaN); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([1,2,3,4,5], slicedArray, "buf.slice(NaN) returns the same elements as the original ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "buf.slice(NaN) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(Number.NEGATIVE_INFINITY); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([1,2,3,4,5], slicedArray, "buf.slice(Number.NEGATIVE_INFINITY) returns the same elements as the original ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(5, sliced.byteLength, "buf.slice(Number.NEGATIVE_INFINITY) returns an ArrayBuffer with byteLength = 5"); |
| |
| var sliced = buf.slice(len-1,len); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([5], slicedArray, "buf.slice(len-1,len) returns the last element from the original ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(1, sliced.byteLength, "buf.slice(len-1,len) returns an ArrayBuffer with byteLength = 1"); |
| |
| var sliced = buf.slice(len,len); |
| var slicedArray = new Uint8Array(sliced); |
| assert.areEqual([], slicedArray, "buf.slice(len,len) returns an empty ArrayBuffer"); |
| assert.isFalse(buf === sliced, "slice returns a new ArrayBuffer - not the original"); |
| assert.areEqual(0, sliced.byteLength, "buf.slice(len,len) returns an ArrayBuffer with byteLength = 0"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.byteLength API shape", |
| body: function() { |
| assert.isTrue(ArrayBuffer.prototype.hasOwnProperty('byteLength'), "ArrayBuffer.prototype.hasOwnProperty('byteLength') == true"); |
| |
| var descriptor = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength'); |
| |
| assert.isTrue(descriptor !== undefined, "Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength') !== undefined"); |
| |
| assert.isTrue(descriptor.get !== undefined, "ArrayBuffer.prototype.byteLength.get !== undefined"); |
| assert.isTrue(typeof descriptor.get === 'function', "typeof ArrayBuffer.prototype.byteLength.get === 'function'"); |
| assert.areEqual(0, descriptor.get.length, "ArrayBuffer.prototype.byteLength.get.length === 0"); |
| |
| assert.isTrue(descriptor.set === undefined, "ArrayBuffer.prototype.byteLength.set === undefined"); |
| |
| assert.isFalse(descriptor.enumerable, "ArrayBuffer.prototype.byteLength.enumerable === false"); |
| assert.isTrue(descriptor.configurable, "ArrayBuffer.prototype.byteLength.configurable === true"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.byteLength behavior", |
| body: function() { |
| var buf = new ArrayBuffer(10); |
| |
| assert.areEqual(10, buf.byteLength, "byteLength returns the same value passed to ArrayBuffer constructor"); |
| |
| // Assignment has no effect since buf.byteLength does not have a setter |
| buf.byteLength = -1; |
| assert.areEqual(10, buf.byteLength, "Assigning to byteLength has no effect"); |
| |
| var descriptor = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength'); |
| |
| assert.throws(function () { descriptor.get(); }, TypeError, "ArrayBuffer.prototype.byteLength called with no 'this' argument", "ArrayBuffer object expected"); |
| assert.areEqual(10, descriptor.get.call(buf), "Calling getter directly returns expected byteLength"); |
| |
| assert.throws(function () { descriptor.get.apply(ArrayBuffer.prototype) }, TypeError, "Applying getter with ArrayBuffer.prototype fails", "ArrayBuffer object expected"); |
| assert.throws(function () { ArrayBuffer.prototype.byteLength; }, TypeError, "Calling ArrayBuffer.prototype.byteLength fails", "ArrayBuffer object expected"); |
| |
| Object.defineProperty(ArrayBuffer.prototype, "byteLength", {value: 'something'}); |
| |
| assert.areEqual('string', typeof ArrayBuffer.prototype.byteLength, "Override ArrayBuffer.prototype.byteLength via Object.defineProperty works"); |
| assert.areEqual('something', ArrayBuffer.prototype.byteLength, "Override ArrayBuffer.prototype.byteLength via Object.defineProperty works"); |
| assert.areEqual('something', buf.byteLength, "Override ArrayBuffer.prototype.byteLength via Object.defineProperty affects instance objects"); |
| |
| Object.defineProperty(ArrayBuffer.prototype, "byteLength", {get: descriptor.get}); |
| } |
| }, |
| { |
| name: "BLUE: 614563 - %TypedArray%.prototype.subarray should use 0 as the default value for the begin argument", |
| body: function() { |
| var arr = new Uint8Array(10); |
| |
| for (var i = 0; i < arr.length; i++) { |
| arr[i] = i; |
| } |
| |
| assert.areEqual([0,1,2,3,4,5,6,7,8,9], arr.subarray(), "Subarray with no begin or end offsets uses 0 and length as respective default values"); |
| } |
| }, |
| { |
| name: "%TypedArray%.prototype.subarray tests on constructor access through [@@species] - special cases", |
| body: function() { |
| var arr = new Uint8Array(10); |
| |
| arr.constructor = undefined; |
| assert.doesNotThrow(function () { arr.subarray(); }, "With [@@species] defined, calling %TypedArray%.prototype.subarray does not throw TypeError even when constructor property is undefined"); |
| |
| arr.constructor = null; |
| assert.throws(function () { arr.subarray(); }, TypeError, "Calling %TypedArray%.prototype.subarray throws TypeError when constructor property is null or not an object", "'[constructor]' is null or not an object"); |
| |
| arr.constructor = 'some string'; |
| assert.throws(function () { arr.subarray(); }, TypeError, "Calling %TypedArray%.prototype.subarray throws TypeError when constructor property is null or not an object", "'[constructor]' is null or not an object"); |
| |
| arr.constructor = Math.sin; |
| assert.doesNotThrow(function () { arr.subarray(); }, "Calling %TypedArray%.prototype.subarray uses default typed array constructor when constructor property is not a constructor"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice tests on constructor access through [@@species]", |
| body: function() { |
| var arr = new ArrayBuffer(10); |
| arr.constructor = Array; |
| |
| assert.throws(function () { arr.slice(); }, TypeError, "Calling ArrayBuffer.prototype.slice throws TypeError when constructor function returns non-ArrayBuffer object", "ArrayBuffer object expected"); |
| |
| arr.constructor = function(newLen) { return arr; } |
| |
| assert.areNotEqual(arr, arr.slice(), "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| |
| arr.constructor = function(newLen) { return new ArrayBuffer(5); } |
| |
| assert.doesNotThrow(function () { arr.slice(); }, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| |
| arr.constructor = function(newLen) { return new ArrayBuffer(newLen); } |
| var o = arr.slice(); |
| |
| assert.areEqual(10, o.byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| |
| arr.constructor = function(newLen) { return new ArrayBuffer(20); } |
| var o = arr.slice(); |
| |
| assert.areEqual(10, o.byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| } |
| }, |
| { |
| name: "ArrayBuffer.prototype.slice tests on constructor access through [@@species] - special cases", |
| body: function() { |
| var arr = new ArrayBuffer(10); |
| |
| arr.constructor = undefined; |
| assert.doesNotThrow(function () { arr.slice(); }, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| assert.areEqual(10, arr.slice().byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| |
| arr.constructor = null; |
| assert.throws(function () { arr.slice(); }, TypeError, "Calling ArrayBuffer.prototype.slice throws TypeError when constructor property is null or not an object", "'[constructor]' is null or not an object"); |
| |
| arr.constructor = 'some string'; |
| assert.throws(function () { arr.slice(); }, TypeError, "Calling ArrayBuffer.prototype.slice throws TypeError when constructor property is null or not an object", "'[constructor]' is null or not an object"); |
| |
| arr.constructor = Math.sin; |
| assert.doesNotThrow(function () { arr.slice(); }, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| assert.areEqual(10, arr.slice().byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has no [@@species] property"); |
| } |
| }, |
| { |
| name: "Test of speciesConstructor codepaths accessing [@@species] through ArrayBuffer.prototype.slice", |
| body: function() { |
| var arr = new ArrayBuffer(10); |
| |
| arr.constructor = function() {}; |
| arr.constructor[Symbol.species] = undefined; |
| assert.doesNotThrow(function () { arr.slice(); }, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has [@@species] == undefined"); |
| assert.areEqual(10, arr.slice().byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has [@@species] == undefined"); |
| |
| arr.constructor[Symbol.species] = null; |
| assert.doesNotThrow(function () { arr.slice(); }, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has [@@species] == undefined"); |
| assert.areEqual(10, arr.slice().byteLength, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has [@@species] == undefined"); |
| |
| arr.constructor[Symbol.species] = {}; |
| assert.throws(function () { arr.slice(); }, TypeError, "Calling ArrayBuffer.prototype.slice will use default constructor if [constructor] has [@@species] == undefined", "Function 'constructor[Symbol.species]' is not a constructor"); |
| } |
| }, |
| { |
| name: "TypedArray constructors cannot be called without new keyword", |
| body: function() { |
| assert.throws(function() { Int8Array(64); }, TypeError, "Calling Int8Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Uint8Array(64); }, TypeError, "Calling Uint8Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Uint8ClampedArray(64); }, TypeError, "Calling Uint8ClampedArray() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Int16Array(64); }, TypeError, "Calling Int16Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Uint16Array(64); }, TypeError, "Calling Uint16Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Int32Array(64); }, TypeError, "Calling Int32Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Uint32Array(64); }, TypeError, "Calling Uint32Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Float32Array(64); }, TypeError, "Calling Float32Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| assert.throws(function() { Float64Array(64); }, TypeError, "Calling Float64Array() without new keyword throws TypeError", "[TypedArray]: cannot be called without the new keyword"); |
| |
| assert.throws(function() { ArrayBuffer(64); }, TypeError, "Calling ArrayBuffer() without new keyword throws TypeError", "ArrayBuffer: cannot be called without the new keyword"); |
| assert.throws(function() { DataView(64); }, TypeError, "Calling DataView() without new keyword throws TypeError", "DataView: cannot be called without the new keyword"); |
| } |
| }, |
| ]; |
| |
| testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" }); |