Google Git
Sign in
webkit / WebKit / ffcc7819a1b141a828570afd787bee17a7758ade / . / JSTests / ChakraCore / test / es6 / ES6TypedArrayExtensions.js
blob: b3a79071eb85ecd5c389d1127677fe31a25e7a89 [file] [log] [blame]
//-------------------------------------------------------------------------------------------------------
// 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" });