tyler.durden/test262
1
0
Fork 0
mirror of https://github.com/tc39/test262.git synced 2025-07-29 00:44:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Removing parts in resizableArrayBufferUtils.js and adding it in includes,

Browse Source 
while applying review changes from PRs for previously tested methods.
This commit is contained in:
Ioanna M. Dimitriou H 2024-06-29 01:40:39 +02:00 committed by Philip Chimento
parent 14de2ce388
commit 3dde047c84
5 changed files with 362 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
test/built-ins/Array/prototype/includes/coerced-searchelement-fromindex-resize.js vendored
View File

@ -6,59 +6,17 @@ esid: sec-array.prototype.includes
description: > description: >
Array.p.includes behaves correctly when the receiver is resized during Array.p.includes behaves correctly when the receiver is resized during
argument coercion argument coercion
includes: [resizableArrayBufferUtils.js]
features: [resizable-arraybuffer, Array.prototype.includes] features: [resizable-arraybuffer, Array.prototype.includes]
---*/ ---*/
class MyUint8Array extends Uint8Array { function ArrayIncludesNumOrBigInt(array, n, fromIndex) {
}
class MyFloat32Array extends Float32Array {
}
class MyBigInt64Array extends BigInt64Array {
}
const builtinCtors = [
Uint8Array,
Int8Array,
Uint16Array,
Int16Array,
Uint32Array,
Int32Array,
Float32Array,
Float64Array,
Uint8ClampedArray,
BigUint64Array,
BigInt64Array
];
const ctors = [
...builtinCtors,
MyUint8Array,
MyFloat32Array,
MyBigInt64Array
];
function CreateResizableArrayBuffer(byteLength, maxByteLength) {
return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength });
}
function WriteToTypedArray(array, index, value) {
if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
array[index] = BigInt(value);
} else {
array[index] = value;
}
}
function ArrayIncludesHelper(array, n, fromIndex) {
if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) { if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) {
return Array.prototype.includes.call(array, BigInt(n), fromIndex); return Array.prototype.includes.call(array, BigInt(n), fromIndex);
} }
return Array.prototype.includes.call(array, n, fromIndex); return Array.prototype.includes.call(array, n, fromIndex);
} }
function IncludesParameterConversionResizes() {
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
const fixedLength = new ctor(rab, 0, 4); const fixedLength = new ctor(rab, 0, 4);
@ -68,9 +26,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!ArrayIncludesHelper(fixedLength, undefined)); assert(!ArrayIncludesNumOrBigInt(fixedLength, undefined));
// The TA is OOB so it includes only "undefined". // The TA is OOB so it includes only "undefined".
assert(ArrayIncludesHelper(fixedLength, undefined, evil)); assert(ArrayIncludesNumOrBigInt(fixedLength, undefined, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -81,9 +39,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(ArrayIncludesHelper(fixedLength, 0)); assert(ArrayIncludesNumOrBigInt(fixedLength, 0));
// The TA is OOB so it includes only "undefined". // The TA is OOB so it includes only "undefined".
assert(!ArrayIncludesHelper(fixedLength, 0, evil)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 0, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -94,9 +52,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!ArrayIncludesHelper(lengthTracking, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, undefined));
// "includes" iterates until the original length and sees "undefined"s. // "includes" iterates until the original length and sees "undefined"s.
assert(ArrayIncludesHelper(lengthTracking, undefined, evil)); assert(ArrayIncludesNumOrBigInt(lengthTracking, undefined, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -110,9 +68,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!ArrayIncludesHelper(lengthTracking, 0)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, 0));
// The TA grew but we only look at the data until the original length. // The TA grew but we only look at the data until the original length.
assert(!ArrayIncludesHelper(lengthTracking, 0, evil)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, 0, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -124,11 +82,8 @@ function IncludesParameterConversionResizes() {
return -4; return -4;
} }
}; };
assert(ArrayIncludesHelper(lengthTracking, 1, -4)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 1, -4));
// The TA grew but the start index conversion is done based on the original // The TA grew but the start index conversion is done based on the original
// length. // length.
assert(ArrayIncludesHelper(lengthTracking, 1, evil)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 1, evil));
} }
}
IncludesParameterConversionResizes();

159
test/built-ins/Array/prototype/includes/resizable-buffer.js vendored
View File

@ -6,59 +6,17 @@ esid: sec-array.prototype.includes
description: > description: >
Array.p.includes behaves correctly when receiver is backed by resizable Array.p.includes behaves correctly when receiver is backed by resizable
buffer buffer
includes: [resizableArrayBufferUtils.js]
features: [resizable-arraybuffer, Array.prototype.includes] features: [resizable-arraybuffer, Array.prototype.includes]
---*/ ---*/
class MyUint8Array extends Uint8Array { function ArrayIncludesNumOrBigInt(array, n, fromIndex) {
}
class MyFloat32Array extends Float32Array {
}
class MyBigInt64Array extends BigInt64Array {
}
const builtinCtors = [
Uint8Array,
Int8Array,
Uint16Array,
Int16Array,
Uint32Array,
Int32Array,
Float32Array,
Float64Array,
Uint8ClampedArray,
BigUint64Array,
BigInt64Array
];
const ctors = [
...builtinCtors,
MyUint8Array,
MyFloat32Array,
MyBigInt64Array
];
function CreateResizableArrayBuffer(byteLength, maxByteLength) {
return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength });
}
function WriteToTypedArray(array, index, value) {
if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
array[index] = BigInt(value);
} else {
array[index] = value;
}
}
function ArrayIncludesHelper(array, n, fromIndex) {
if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) { if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) {
return Array.prototype.includes.call(array, BigInt(n), fromIndex); return Array.prototype.includes.call(array, BigInt(n), fromIndex);
} }
return Array.prototype.includes.call(array, n, fromIndex); return Array.prototype.includes.call(array, n, fromIndex);
} }
function TestIncludes() {
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
const fixedLength = new ctor(rab, 0, 4); const fixedLength = new ctor(rab, 0, 4);
@ -78,32 +36,32 @@ function TestIncludes() {
// [0, 2, 4, 6, ...] << lengthTracking // [0, 2, 4, 6, ...] << lengthTracking
// [4, 6, ...] << lengthTrackingWithOffset // [4, 6, ...] << lengthTrackingWithOffset
assert(ArrayIncludesHelper(fixedLength, 2)); assert(ArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!ArrayIncludesHelper(fixedLength, undefined)); assert(!ArrayIncludesNumOrBigInt(fixedLength, undefined));
assert(ArrayIncludesHelper(fixedLength, 2, 1)); assert(ArrayIncludesNumOrBigInt(fixedLength, 2, 1));
assert(!ArrayIncludesHelper(fixedLength, 2, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 2, 2));
assert(ArrayIncludesHelper(fixedLength, 2, -3)); assert(ArrayIncludesNumOrBigInt(fixedLength, 2, -3));
assert(!ArrayIncludesHelper(fixedLength, 2, -2)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 2, -2));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(ArrayIncludesHelper(fixedLengthWithOffset, 4)); assert(ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, undefined)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, undefined));
assert(ArrayIncludesHelper(fixedLengthWithOffset, 4, 0)); assert(ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, 0));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 4, 1)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, 1));
assert(ArrayIncludesHelper(fixedLengthWithOffset, 4, -2)); assert(ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, -2));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 4, -1)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, -1));
assert(ArrayIncludesHelper(lengthTracking, 2)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!ArrayIncludesHelper(lengthTracking, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(ArrayIncludesHelper(lengthTracking, 2, 1)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 2, 1));
assert(!ArrayIncludesHelper(lengthTracking, 2, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, 2, 2));
assert(ArrayIncludesHelper(lengthTracking, 2, -3)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 2, -3));
assert(!ArrayIncludesHelper(lengthTracking, 2, -2)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, 2, -2));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 4, 0)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, 0));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 4, 1)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, 1));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 4, -2)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, -2));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 4, -1)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, -1));
// Shrink so that fixed length TAs go out of bounds. // Shrink so that fixed length TAs go out of bounds.
rab.resize(3 * ctor.BYTES_PER_ELEMENT); rab.resize(3 * ctor.BYTES_PER_ELEMENT);
@ -112,29 +70,29 @@ function TestIncludes() {
// [0, 2, 4, ...] << lengthTracking // [0, 2, 4, ...] << lengthTracking
// [4, ...] << lengthTrackingWithOffset // [4, ...] << lengthTrackingWithOffset
assert(!ArrayIncludesHelper(fixedLength, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(ArrayIncludesHelper(lengthTracking, 2)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!ArrayIncludesHelper(lengthTracking, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
// Shrink so that the TAs with offset go out of bounds. // Shrink so that the TAs with offset go out of bounds.
rab.resize(1 * ctor.BYTES_PER_ELEMENT); rab.resize(1 * ctor.BYTES_PER_ELEMENT);
assert(!ArrayIncludesHelper(fixedLength, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
// Shrink to zero. // Shrink to zero.
rab.resize(0); rab.resize(0);
assert(!ArrayIncludesHelper(fixedLength, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(!ArrayIncludesHelper(lengthTracking, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!ArrayIncludesHelper(lengthTracking, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, undefined));
// Grow so that all TAs are back in-bounds. // Grow so that all TAs are back in-bounds.
rab.resize(6 * ctor.BYTES_PER_ELEMENT); rab.resize(6 * ctor.BYTES_PER_ELEMENT);
@ -148,21 +106,18 @@ function TestIncludes() {
// [0, 2, 4, 6, 8, 10, ...] << lengthTracking // [0, 2, 4, 6, 8, 10, ...] << lengthTracking
// [4, 6, 8, 10, ...] << lengthTrackingWithOffset // [4, 6, 8, 10, ...] << lengthTrackingWithOffset
assert(ArrayIncludesHelper(fixedLength, 2)); assert(ArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!ArrayIncludesHelper(fixedLength, undefined)); assert(!ArrayIncludesNumOrBigInt(fixedLength, undefined));
assert(!ArrayIncludesHelper(fixedLength, 8)); assert(!ArrayIncludesNumOrBigInt(fixedLength, 8));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(ArrayIncludesHelper(fixedLengthWithOffset, 4)); assert(ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, undefined)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, undefined));
assert(!ArrayIncludesHelper(fixedLengthWithOffset, 8)); assert(!ArrayIncludesNumOrBigInt(fixedLengthWithOffset, 8));
assert(ArrayIncludesHelper(lengthTracking, 2)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!ArrayIncludesHelper(lengthTracking, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(ArrayIncludesHelper(lengthTracking, 8)); assert(ArrayIncludesNumOrBigInt(lengthTracking, 8));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!ArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
assert(ArrayIncludesHelper(lengthTrackingWithOffset, 8)); assert(ArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 8));
} }
}
TestIncludes();

69
test/built-ins/TypedArray/prototype/includes/coerced-searchelement-fromindex-resize.js vendored
View File

@ -6,59 +6,17 @@ esid: sec-%typedarray%.prototype.includes
description: > description: >
TypedArray.p.includes behaves correctly when the receiver is resized during TypedArray.p.includes behaves correctly when the receiver is resized during
argument coercion argument coercion
includes: [resizableArrayBufferUtils.js]
features: [resizable-arraybuffer, Array.prototype.includes] features: [resizable-arraybuffer, Array.prototype.includes]
---*/ ---*/
class MyUint8Array extends Uint8Array { function TypedArrayIncludesNumOrBigInt(array, n, fromIndex) {
}
class MyFloat32Array extends Float32Array {
}
class MyBigInt64Array extends BigInt64Array {
}
const builtinCtors = [
Uint8Array,
Int8Array,
Uint16Array,
Int16Array,
Uint32Array,
Int32Array,
Float32Array,
Float64Array,
Uint8ClampedArray,
BigUint64Array,
BigInt64Array
];
const ctors = [
...builtinCtors,
MyUint8Array,
MyFloat32Array,
MyBigInt64Array
];
function CreateResizableArrayBuffer(byteLength, maxByteLength) {
return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength });
}
function WriteToTypedArray(array, index, value) {
if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
array[index] = BigInt(value);
} else {
array[index] = value;
}
}
function TypedArrayIncludesHelper(array, n, fromIndex) {
if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) { if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) {
return array.includes(BigInt(n), fromIndex); return array.includes(BigInt(n), fromIndex);
} }
return array.includes(n, fromIndex); return array.includes(n, fromIndex);
} }
function IncludesParameterConversionResizes() {
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
const fixedLength = new ctor(rab, 0, 4); const fixedLength = new ctor(rab, 0, 4);
@ -68,9 +26,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!TypedArrayIncludesHelper(fixedLength, undefined)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, undefined));
// The TA is OOB so it includes only "undefined". // The TA is OOB so it includes only "undefined".
assert(TypedArrayIncludesHelper(fixedLength, undefined, evil)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, undefined, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -81,9 +39,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(TypedArrayIncludesHelper(fixedLength, 0)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, 0));
// The TA is OOB so it includes only "undefined". // The TA is OOB so it includes only "undefined".
assert(!TypedArrayIncludesHelper(fixedLength, 0, evil)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, 0, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -94,9 +52,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!TypedArrayIncludesHelper(lengthTracking, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, undefined));
// "includes" iterates until the original length and sees "undefined"s. // "includes" iterates until the original length and sees "undefined"s.
assert(TypedArrayIncludesHelper(lengthTracking, undefined, evil)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, undefined, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -110,9 +68,9 @@ function IncludesParameterConversionResizes() {
return 0; return 0;
} }
}; };
assert(!TypedArrayIncludesHelper(lengthTracking, 0)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, 0));
// The TA grew but we only look at the data until the original length. // The TA grew but we only look at the data until the original length.
assert(!TypedArrayIncludesHelper(lengthTracking, 0, evil)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, 0, evil));
} }
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
@ -124,11 +82,8 @@ function IncludesParameterConversionResizes() {
return -4; return -4;
} }
}; };
assert(TypedArrayIncludesHelper(lengthTracking, 1, -4)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 1, -4));
// The TA grew but the start index conversion is done based on the original // The TA grew but the start index conversion is done based on the original
// length. // length.
assert(TypedArrayIncludesHelper(lengthTracking, 1, evil)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 1, evil));
} }
}
IncludesParameterConversionResizes();

14
test/built-ins/TypedArray/prototype/includes/resizable-buffer-special-float-values.js vendored
View File

@ -6,22 +6,10 @@ esid: sec-%typedarray%.prototype.includes
description: > description: >
TypedArray.p.includes behaves correctly for special float values when TypedArray.p.includes behaves correctly for special float values when
receiver is a float TypedArray backed by a resizable buffer receiver is a float TypedArray backed by a resizable buffer
includes: [resizableArrayBufferUtils.js]
features: [resizable-arraybuffer, Array.prototype.includes] features: [resizable-arraybuffer, Array.prototype.includes]
---*/ ---*/
class MyFloat32Array extends Float32Array {
}
const floatCtors = [
Float32Array,
Float64Array,
MyFloat32Array
];
function CreateResizableArrayBuffer(byteLength, maxByteLength) {
return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength });
}
for (let ctor of floatCtors) { for (let ctor of floatCtors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
const lengthTracking = new ctor(rab); const lengthTracking = new ctor(rab);

159
test/built-ins/TypedArray/prototype/includes/resizable-buffer.js vendored
View File

@ -6,59 +6,17 @@ esid: sec-%typedarray%.prototype.includes
description: > description: >
TypedArray.p.includes behaves correctly when receiver is backed by resizable TypedArray.p.includes behaves correctly when receiver is backed by resizable
buffer buffer
includes: [resizableArrayBufferUtils.js]
features: [resizable-arraybuffer, Array.prototype.includes] features: [resizable-arraybuffer, Array.prototype.includes]
---*/ ---*/
class MyUint8Array extends Uint8Array { function TypedArrayIncludesNumOrBigInt(array, n, fromIndex) {
}
class MyFloat32Array extends Float32Array {
}
class MyBigInt64Array extends BigInt64Array {
}
const builtinCtors = [
Uint8Array,
Int8Array,
Uint16Array,
Int16Array,
Uint32Array,
Int32Array,
Float32Array,
Float64Array,
Uint8ClampedArray,
BigUint64Array,
BigInt64Array
];
const ctors = [
...builtinCtors,
MyUint8Array,
MyFloat32Array,
MyBigInt64Array
];
function CreateResizableArrayBuffer(byteLength, maxByteLength) {
return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength });
}
function WriteToTypedArray(array, index, value) {
if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
array[index] = BigInt(value);
} else {
array[index] = value;
}
}
function TypedArrayIncludesHelper(array, n, fromIndex) {
if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) { if (typeof n == 'number' && (array instanceof BigInt64Array || array instanceof BigUint64Array)) {
return array.includes(BigInt(n), fromIndex); return array.includes(BigInt(n), fromIndex);
} }
return array.includes(n, fromIndex); return array.includes(n, fromIndex);
} }
function TestIncludes() {
for (let ctor of ctors) { for (let ctor of ctors) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
const fixedLength = new ctor(rab, 0, 4); const fixedLength = new ctor(rab, 0, 4);
@ -78,32 +36,32 @@ function TestIncludes() {
// [0, 2, 4, 6, ...] << lengthTracking // [0, 2, 4, 6, ...] << lengthTracking
// [4, 6, ...] << lengthTrackingWithOffset // [4, 6, ...] << lengthTrackingWithOffset
assert(TypedArrayIncludesHelper(fixedLength, 2)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!TypedArrayIncludesHelper(fixedLength, undefined)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, undefined));
assert(TypedArrayIncludesHelper(fixedLength, 2, 1)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, 2, 1));
assert(!TypedArrayIncludesHelper(fixedLength, 2, 2)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, 2, 2));
assert(TypedArrayIncludesHelper(fixedLength, 2, -3)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, 2, -3));
assert(!TypedArrayIncludesHelper(fixedLength, 2, -2)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, 2, -2));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(TypedArrayIncludesHelper(fixedLengthWithOffset, 4)); assert(TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, undefined)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, undefined));
assert(TypedArrayIncludesHelper(fixedLengthWithOffset, 4, 0)); assert(TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, 0));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, 4, 1)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, 1));
assert(TypedArrayIncludesHelper(fixedLengthWithOffset, 4, -2)); assert(TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, -2));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, 4, -1)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4, -1));
assert(TypedArrayIncludesHelper(lengthTracking, 2)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!TypedArrayIncludesHelper(lengthTracking, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(TypedArrayIncludesHelper(lengthTracking, 2, 1)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 2, 1));
assert(!TypedArrayIncludesHelper(lengthTracking, 2, 2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, 2, 2));
assert(TypedArrayIncludesHelper(lengthTracking, 2, -3)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 2, -3));
assert(!TypedArrayIncludesHelper(lengthTracking, 2, -2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, 2, -2));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 4, 0)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, 0));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, 4, 1)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, 1));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 4, -2)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, -2));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, 4, -1)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4, -1));
// Shrink so that fixed length TAs go out of bounds. // Shrink so that fixed length TAs go out of bounds.
rab.resize(3 * ctor.BYTES_PER_ELEMENT); rab.resize(3 * ctor.BYTES_PER_ELEMENT);
@ -113,43 +71,43 @@ function TestIncludes() {
// [4, ...] << lengthTrackingWithOffset // [4, ...] << lengthTrackingWithOffset
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLength, 2); TypedArrayIncludesNumOrBigInt(fixedLength, 2);
}); });
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLengthWithOffset, 2); TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2);
}); });
assert(TypedArrayIncludesHelper(lengthTracking, 2)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!TypedArrayIncludesHelper(lengthTracking, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
// Shrink so that the TAs with offset go out of bounds. // Shrink so that the TAs with offset go out of bounds.
rab.resize(1 * ctor.BYTES_PER_ELEMENT); rab.resize(1 * ctor.BYTES_PER_ELEMENT);
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLength, 2); TypedArrayIncludesNumOrBigInt(fixedLength, 2);
}); });
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLengthWithOffset, 2); TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2);
}); });
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(lengthTrackingWithOffset, 2); TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2);
}); });
// Shrink to zero. // Shrink to zero.
rab.resize(0); rab.resize(0);
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLength, 2); TypedArrayIncludesNumOrBigInt(fixedLength, 2);
}); });
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(fixedLengthWithOffset, 2); TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2);
}); });
assert.throws(TypeError, () => { assert.throws(TypeError, () => {
TypedArrayIncludesHelper(lengthTrackingWithOffset, 2); TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2);
}); });
assert(!TypedArrayIncludesHelper(lengthTracking, 2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!TypedArrayIncludesHelper(lengthTracking, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, undefined));
// Grow so that all TAs are back in-bounds. // Grow so that all TAs are back in-bounds.
rab.resize(6 * ctor.BYTES_PER_ELEMENT); rab.resize(6 * ctor.BYTES_PER_ELEMENT);
@ -163,21 +121,18 @@ function TestIncludes() {
// [0, 2, 4, 6, 8, 10, ...] << lengthTracking // [0, 2, 4, 6, 8, 10, ...] << lengthTracking
// [4, 6, 8, 10, ...] << lengthTrackingWithOffset // [4, 6, 8, 10, ...] << lengthTrackingWithOffset
assert(TypedArrayIncludesHelper(fixedLength, 2)); assert(TypedArrayIncludesNumOrBigInt(fixedLength, 2));
assert(!TypedArrayIncludesHelper(fixedLength, undefined)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, undefined));
assert(!TypedArrayIncludesHelper(fixedLength, 8)); assert(!TypedArrayIncludesNumOrBigInt(fixedLength, 8));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, 2)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 2));
assert(TypedArrayIncludesHelper(fixedLengthWithOffset, 4)); assert(TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 4));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, undefined)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, undefined));
assert(!TypedArrayIncludesHelper(fixedLengthWithOffset, 8)); assert(!TypedArrayIncludesNumOrBigInt(fixedLengthWithOffset, 8));
assert(TypedArrayIncludesHelper(lengthTracking, 2)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 2));
assert(!TypedArrayIncludesHelper(lengthTracking, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTracking, undefined));
assert(TypedArrayIncludesHelper(lengthTracking, 8)); assert(TypedArrayIncludesNumOrBigInt(lengthTracking, 8));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, 2)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 2));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 4)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 4));
assert(!TypedArrayIncludesHelper(lengthTrackingWithOffset, undefined)); assert(!TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, undefined));
assert(TypedArrayIncludesHelper(lengthTrackingWithOffset, 8)); assert(TypedArrayIncludesNumOrBigInt(lengthTrackingWithOffset, 8));
} }
}
TestIncludes();