Skip to content

Commit

Permalink
Removing parts in resizableArrayBufferUtils.js and adding it in inclu…
Browse files Browse the repository at this point in the history 
…des,

while adjusting usage of CollectValuesAndResize and applying review changes
from PRs for previously tested methods.
  • Loading branch information
@ioannad @ptomato
ioannad authored and ptomato committed Jul 4, 2024
1 parent 193184b commit 3d35b0b
Show file tree
Hide file tree
Showing 6 changed files with 418 additions and 754 deletions.
192 changes: 66 additions & 126 deletions test/built-ins/Array/prototype/findIndex/resizable-buffer-grow-mid-iteration.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,139 +6,79 @@ esid: sec-array.prototype.findindex
description: >
Array.p.findIndex behaves correctly when receiver is backed by resizable
buffer that is grown mid-iteration
includes: [compareArray.js]
includes: [compareArray.js, resizableArrayBufferUtils.js]
features: [resizable-arraybuffer]
---*/

class MyUint8Array extends Uint8Array {
let values;
let rab;
let resizeAfter;
let resizeTo;
// Collects the view of the resizable array buffer rab into values, with an
// iteration during which, after resizeAfter steps, rab is resized to length
// resizeTo. To be called by a method of the view being collected.
// Note that rab, values, resizeAfter, and resizeTo may need to be reset before
// calling this.
function ResizeBufferMidIteration(n) {
CollectValuesAndResize(n, values, rab, resizeAfter, resizeTo);
return false;
}

class MyFloat32Array extends Float32Array {
// Orig. array: [0, 2, 4, 6]
// [0, 2, 4, 6] << fixedLength
// [4, 6] << fixedLengthWithOffset
// [0, 2, 4, 6, ...] << lengthTracking
// [4, 6, ...] << lengthTrackingWithOffset
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const fixedLength = new ctor(rab, 0, 4);
values = [];
resizeAfter = 2;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(Array.prototype.findIndex.call(fixedLength, ResizeBufferMidIteration), -1);
assert.compareArray(values, [
0,
2,
4,
6
]);
}

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 });
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
values = [];
resizeAfter = 1;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(Array.prototype.findIndex.call(fixedLengthWithOffset, ResizeBufferMidIteration), -1);
assert.compareArray(values, [
4,
6
]);
}

function WriteToTypedArray(array, index, value) {
if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
array[index] = BigInt(value);
} else {
array[index] = value;
}
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const lengthTracking = new ctor(rab, 0);
values = [];
resizeAfter = 2;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(Array.prototype.findIndex.call(lengthTracking, ResizeBufferMidIteration), -1);
assert.compareArray(values, [
0,
2,
4,
6
]);
}

function ArrayFindIndexHelper(ta, p) {
return Array.prototype.findIndex.call(ta, p);
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
values = [];
resizeAfter = 1;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(Array.prototype.findIndex.call(lengthTrackingWithOffset, ResizeBufferMidIteration), -1);
assert.compareArray(values, [
4,
6
]);
}

function FindIndexGrowMidIteration() {
// Orig. array: [0, 2, 4, 6]
// [0, 2, 4, 6] << fixedLength
// [4, 6] << fixedLengthWithOffset
// [0, 2, 4, 6, ...] << lengthTracking
// [4, 6, ...] << lengthTrackingWithOffset
function CreateRabForTest(ctor) {
const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT);
// Write some data into the array.
const taWrite = new ctor(rab);
for (let i = 0; i < 4; ++i) {
WriteToTypedArray(taWrite, i, 2 * i);
}
return rab;
}
let values;
let rab;
let resizeAfter;
let resizeTo;
function CollectValuesAndResize(n) {
if (typeof n == 'bigint') {
values.push(Number(n));
} else {
values.push(n);
}
if (values.length == resizeAfter) {
rab.resize(resizeTo);
}
return false;
}
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const fixedLength = new ctor(rab, 0, 4);
values = [];
resizeAfter = 2;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(ArrayFindIndexHelper(fixedLength, CollectValuesAndResize), -1);
assert.compareArray(values, [
0,
2,
4,
6
]);
}
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
values = [];
resizeAfter = 1;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(ArrayFindIndexHelper(fixedLengthWithOffset, CollectValuesAndResize), -1);
assert.compareArray(values, [
4,
6
]);
}
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const lengthTracking = new ctor(rab, 0);
values = [];
resizeAfter = 2;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(ArrayFindIndexHelper(lengthTracking, CollectValuesAndResize), -1);
assert.compareArray(values, [
0,
2,
4,
6
]);
}
for (let ctor of ctors) {
rab = CreateRabForTest(ctor);
const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
values = [];
resizeAfter = 1;
resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
assert.sameValue(ArrayFindIndexHelper(lengthTrackingWithOffset, CollectValuesAndResize), -1);
assert.compareArray(values, [
4,
6
]);
}
}

FindIndexGrowMidIteration();

Loading

0 comments on commit 3d35b0b

Please sign in to comment.