From efa60b323c3a7c59ab8cd0a1131133c06023e40f Mon Sep 17 00:00:00 2001 From: "Ioanna M. Dimitriou H" Date: Wed, 8 May 2024 16:19:03 +0200 Subject: [PATCH] Addressed relevant review comment from .at method tests. https://github.com/tc39/test262/pull/4070#discussion_r1591648535 --- .../resizable-buffer-grow-mid-iteration.js | 195 ++++++----- .../resizable-buffer-shrink-mid-iteration.js | 110 +++---- .../prototype/entries/resizable-buffer.js | 274 ++++++++-------- .../resizable-buffer-grow-mid-iteration.js | 194 ++++++----- .../resizable-buffer-shrink-mid-iteration.js | 110 +++---- .../prototype/entries/resizable-buffer.js | 306 +++++++++--------- 6 files changed, 582 insertions(+), 607 deletions(-) diff --git a/test/built-ins/Array/prototype/entries/resizable-buffer-grow-mid-iteration.js b/test/built-ins/Array/prototype/entries/resizable-buffer-grow-mid-iteration.js index d89daad2357..ae5161f844b 100644 --- a/test/built-ins/Array/prototype/entries/resizable-buffer-grow-mid-iteration.js +++ b/test/built-ins/Array/prototype/entries/resizable-buffer-grow-mid-iteration.js @@ -14,105 +14,100 @@ function ArrayEntriesHelper(ta) { return Array.prototype.entries.call(ta); } -function EntriesGrowMidIteration() { - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset +// Orig. array: [0, 2, 4, 6] +// [0, 2, 4, 6] << fixedLength +// [4, 6] << fixedLengthWithOffset +// [0, 2, 4, 6, ...] << lengthTracking +// [4, 6, ...] << lengthTrackingWithOffset - // Iterating with entries() (the 4 loops below). - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLength = new ctor(rab, 0, 4); - // The fixed length array is not affected by resizing. - TestIterationAndResize(ArrayEntriesHelper(fixedLength), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ], - [ - 3, - 6 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - // The fixed length array is not affected by resizing. - TestIterationAndResize(ArrayEntriesHelper(fixedLengthWithOffset), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTracking = new ctor(rab, 0); - TestIterationAndResize(ArrayEntriesHelper(lengthTracking), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ], - [ - 3, - 6 - ], - [ - 4, - 0 - ], - [ - 5, - 0 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); - TestIterationAndResize(ArrayEntriesHelper(lengthTrackingWithOffset), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ], - [ - 2, - 0 - ], - [ - 3, - 0 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } +// Iterating with entries() (the 4 loops below). +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLength = new ctor(rab, 0, 4); + // The fixed length array is not affected by resizing. + TestIterationAndResize(ArrayEntriesHelper(fixedLength), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ], + [ + 3, + 6 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); + // The fixed length array is not affected by resizing. + TestIterationAndResize(ArrayEntriesHelper(fixedLengthWithOffset), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTracking = new ctor(rab, 0); + TestIterationAndResize(ArrayEntriesHelper(lengthTracking), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 0 + ], + [ + 5, + 0 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); + TestIterationAndResize(ArrayEntriesHelper(lengthTrackingWithOffset), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); } - -EntriesGrowMidIteration(); - diff --git a/test/built-ins/Array/prototype/entries/resizable-buffer-shrink-mid-iteration.js b/test/built-ins/Array/prototype/entries/resizable-buffer-shrink-mid-iteration.js index 50c99a21ffe..81ce68d3a3d 100644 --- a/test/built-ins/Array/prototype/entries/resizable-buffer-shrink-mid-iteration.js +++ b/test/built-ins/Array/prototype/entries/resizable-buffer-shrink-mid-iteration.js @@ -14,63 +14,59 @@ function ArrayEntriesHelper(ta) { return Array.prototype.entries.call(ta); } -function EntriesShrinkMidIteration() { - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset - // Iterating with entries() (the 4 loops below). - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLength = new ctor(rab, 0, 4); +// Orig. array: [0, 2, 4, 6] +// [0, 2, 4, 6] << fixedLength +// [4, 6] << fixedLengthWithOffset +// [0, 2, 4, 6, ...] << lengthTracking +// [4, 6, ...] << lengthTrackingWithOffset +// Iterating with entries() (the 4 loops below). +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLength = new ctor(rab, 0, 4); - // The fixed length array goes out of bounds when the RAB is resized. - assert.throws(TypeError, () => { - TestIterationAndResize(ArrayEntriesHelper(fixedLength), null, rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - }); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - - // The fixed length array goes out of bounds when the RAB is resized. - assert.throws(TypeError, () => { - TestIterationAndResize(ArrayEntriesHelper(fixedLengthWithOffset), null, rab, 1, 3 * ctor.BYTES_PER_ELEMENT); - }); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTracking = new ctor(rab, 0); - TestIterationAndResize(ArrayEntriesHelper(lengthTracking), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ] - ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); - TestIterationAndResize(ArrayEntriesHelper(lengthTrackingWithOffset), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ] - ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - } + // The fixed length array goes out of bounds when the RAB is resized. + assert.throws(TypeError, () => { + TestIterationAndResize(ArrayEntriesHelper(fixedLength), null, rab, 2, 3 * ctor.BYTES_PER_ELEMENT); + }); } +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); -EntriesShrinkMidIteration(); + // The fixed length array goes out of bounds when the RAB is resized. + assert.throws(TypeError, () => { + TestIterationAndResize(ArrayEntriesHelper(fixedLengthWithOffset), null, rab, 1, 3 * ctor.BYTES_PER_ELEMENT); + }); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTracking = new ctor(rab, 0); + TestIterationAndResize(ArrayEntriesHelper(lengthTracking), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ] + ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); + TestIterationAndResize(ArrayEntriesHelper(lengthTrackingWithOffset), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); +} diff --git a/test/built-ins/Array/prototype/entries/resizable-buffer.js b/test/built-ins/Array/prototype/entries/resizable-buffer.js index 533c642694d..bbff27fd2a4 100644 --- a/test/built-ins/Array/prototype/entries/resizable-buffer.js +++ b/test/built-ins/Array/prototype/entries/resizable-buffer.js @@ -25,144 +25,140 @@ function ValuesFromArrayEntries(ta) { return result; } -function TestEntries() { - for (let ctor of ctors) { - const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); - const fixedLength = new ctor(rab, 0, 4); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - const lengthTracking = new ctor(rab, 0); - const lengthTrackingWithOffset = new ctor(rab, 2 * 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); - } - - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset - - assert.compareArray(ValuesFromArrayEntries(fixedLength), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromArrayEntries(fixedLengthWithOffset), [ - 4, - 6 - ]); - assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [ - 4, - 6 - ]); - - // Shrink so that fixed length TAs go out of bounds. - rab.resize(3 * ctor.BYTES_PER_ELEMENT); - - // Orig. array: [0, 2, 4] - // [0, 2, 4, ...] << lengthTracking - // [4, ...] << lengthTrackingWithOffset - - // TypedArray.prototype.{entries, keys, values} throw right away when - // called. Array.prototype.{entries, keys, values} don't throw, but when - // we try to iterate the returned ArrayIterator, that throws. - ArrayEntriesHelper(fixedLength); - ArrayEntriesHelper(fixedLengthWithOffset); - - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ - 0, - 2, - 4 - ]); - assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [4]); - - // Shrink so that the TAs with offset go out of bounds. - rab.resize(1 * ctor.BYTES_PER_ELEMENT); - ArrayEntriesHelper(fixedLength); - ArrayEntriesHelper(fixedLengthWithOffset); - ArrayEntriesHelper(lengthTrackingWithOffset); - - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(lengthTrackingWithOffset)); - }); - assert.compareArray(ValuesFromArrayEntries(lengthTracking), [0]); - - // Shrink to zero. - rab.resize(0); - ArrayEntriesHelper(fixedLength); - ArrayEntriesHelper(fixedLengthWithOffset); - ArrayEntriesHelper(lengthTrackingWithOffset); - - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.throws(TypeError, () => { - Array.from(ArrayEntriesHelper(lengthTrackingWithOffset)); - }); - assert.compareArray(ValuesFromArrayEntries(lengthTracking), []); - - // Grow so that all TAs are back in-bounds. - rab.resize(6 * ctor.BYTES_PER_ELEMENT); - for (let i = 0; i < 6; ++i) { - WriteToTypedArray(taWrite, i, 2 * i); - } - - // Orig. array: [0, 2, 4, 6, 8, 10] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, 8, 10, ...] << lengthTracking - // [4, 6, 8, 10, ...] << lengthTrackingWithOffset - - assert.compareArray(ValuesFromArrayEntries(fixedLength), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromArrayEntries(fixedLengthWithOffset), [ - 4, - 6 - ]); - assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ - 0, - 2, - 4, - 6, - 8, - 10 - ]); - assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [ - 4, - 6, - 8, - 10 - ]); +for (let ctor of ctors) { + const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); + const fixedLength = new ctor(rab, 0, 4); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); + const lengthTracking = new ctor(rab, 0); + const lengthTrackingWithOffset = new ctor(rab, 2 * 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); + } + + // Orig. array: [0, 2, 4, 6] + // [0, 2, 4, 6] << fixedLength + // [4, 6] << fixedLengthWithOffset + // [0, 2, 4, 6, ...] << lengthTracking + // [4, 6, ...] << lengthTrackingWithOffset + + assert.compareArray(ValuesFromArrayEntries(fixedLength), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromArrayEntries(fixedLengthWithOffset), [ + 4, + 6 + ]); + assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [ + 4, + 6 + ]); + + // Shrink so that fixed length TAs go out of bounds. + rab.resize(3 * ctor.BYTES_PER_ELEMENT); + + // Orig. array: [0, 2, 4] + // [0, 2, 4, ...] << lengthTracking + // [4, ...] << lengthTrackingWithOffset + + // TypedArray.prototype.{entries, keys, values} throw right away when + // called. Array.prototype.{entries, keys, values} don't throw, but when + // we try to iterate the returned ArrayIterator, that throws. + ArrayEntriesHelper(fixedLength); + ArrayEntriesHelper(fixedLengthWithOffset); + + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ + 0, + 2, + 4 + ]); + assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [4]); + + // Shrink so that the TAs with offset go out of bounds. + rab.resize(1 * ctor.BYTES_PER_ELEMENT); + ArrayEntriesHelper(fixedLength); + ArrayEntriesHelper(fixedLengthWithOffset); + ArrayEntriesHelper(lengthTrackingWithOffset); + + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(lengthTrackingWithOffset)); + }); + assert.compareArray(ValuesFromArrayEntries(lengthTracking), [0]); + + // Shrink to zero. + rab.resize(0); + ArrayEntriesHelper(fixedLength); + ArrayEntriesHelper(fixedLengthWithOffset); + ArrayEntriesHelper(lengthTrackingWithOffset); + + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.throws(TypeError, () => { + Array.from(ArrayEntriesHelper(lengthTrackingWithOffset)); + }); + assert.compareArray(ValuesFromArrayEntries(lengthTracking), []); + + // Grow so that all TAs are back in-bounds. + rab.resize(6 * ctor.BYTES_PER_ELEMENT); + for (let i = 0; i < 6; ++i) { + WriteToTypedArray(taWrite, i, 2 * i); } -} -TestEntries(); + // Orig. array: [0, 2, 4, 6, 8, 10] + // [0, 2, 4, 6] << fixedLength + // [4, 6] << fixedLengthWithOffset + // [0, 2, 4, 6, 8, 10, ...] << lengthTracking + // [4, 6, 8, 10, ...] << lengthTrackingWithOffset + + assert.compareArray(ValuesFromArrayEntries(fixedLength), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromArrayEntries(fixedLengthWithOffset), [ + 4, + 6 + ]); + assert.compareArray(ValuesFromArrayEntries(lengthTracking), [ + 0, + 2, + 4, + 6, + 8, + 10 + ]); + assert.compareArray(ValuesFromArrayEntries(lengthTrackingWithOffset), [ + 4, + 6, + 8, + 10 + ]); +} diff --git a/test/built-ins/TypedArray/prototype/entries/resizable-buffer-grow-mid-iteration.js b/test/built-ins/TypedArray/prototype/entries/resizable-buffer-grow-mid-iteration.js index 848a13c9feb..246c4cb43da 100644 --- a/test/built-ins/TypedArray/prototype/entries/resizable-buffer-grow-mid-iteration.js +++ b/test/built-ins/TypedArray/prototype/entries/resizable-buffer-grow-mid-iteration.js @@ -10,104 +10,100 @@ includes: [compareArray.js, resizableArrayBufferUtils.js] features: [resizable-arraybuffer] ---*/ -function EntriesGrowMidIteration() { - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset +// Orig. array: [0, 2, 4, 6] +// [0, 2, 4, 6] << fixedLength +// [4, 6] << fixedLengthWithOffset +// [0, 2, 4, 6, ...] << lengthTracking +// [4, 6, ...] << lengthTrackingWithOffset - // Iterating with entries() (the 4 loops below). - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLength = new ctor(rab, 0, 4); - // The fixed length array is not affected by resizing. - TestIterationAndResize(fixedLength.entries(), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ], - [ - 3, - 6 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - // The fixed length array is not affected by resizing. - TestIterationAndResize(fixedLengthWithOffset.entries(), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTracking = new ctor(rab, 0); - TestIterationAndResize(lengthTracking.entries(), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ], - [ - 3, - 6 - ], - [ - 4, - 0 - ], - [ - 5, - 0 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); - TestIterationAndResize(lengthTrackingWithOffset.entries(), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ], - [ - 2, - 0 - ], - [ - 3, - 0 - ] - ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); - } +// Iterating with entries() (the 4 loops below). +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLength = new ctor(rab, 0, 4); + // The fixed length array is not affected by resizing. + TestIterationAndResize(fixedLength.entries(), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ], + [ + 3, + 6 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); + // The fixed length array is not affected by resizing. + TestIterationAndResize(fixedLengthWithOffset.entries(), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTracking = new ctor(rab, 0); + TestIterationAndResize(lengthTracking.entries(), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 0 + ], + [ + 5, + 0 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); + TestIterationAndResize(lengthTrackingWithOffset.entries(), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ] + ], rab, 2, 6 * ctor.BYTES_PER_ELEMENT); } - -EntriesGrowMidIteration(); diff --git a/test/built-ins/TypedArray/prototype/entries/resizable-buffer-shrink-mid-iteration.js b/test/built-ins/TypedArray/prototype/entries/resizable-buffer-shrink-mid-iteration.js index 945b795d9fe..29d56978c90 100644 --- a/test/built-ins/TypedArray/prototype/entries/resizable-buffer-shrink-mid-iteration.js +++ b/test/built-ins/TypedArray/prototype/entries/resizable-buffer-shrink-mid-iteration.js @@ -14,63 +14,59 @@ function TypedArrayEntriesHelper(ta) { return ta.entries(); } -function EntriesShrinkMidIteration() { - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset - // Iterating with entries() (the 4 loops below). - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLength = new ctor(rab, 0, 4); +// Orig. array: [0, 2, 4, 6] +// [0, 2, 4, 6] << fixedLength +// [4, 6] << fixedLengthWithOffset +// [0, 2, 4, 6, ...] << lengthTracking +// [4, 6, ...] << lengthTrackingWithOffset +// Iterating with entries() (the 4 loops below). +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLength = new ctor(rab, 0, 4); - // The fixed length array goes out of bounds when the RAB is resized. - assert.throws(TypeError, () => { - TestIterationAndResize(TypedArrayEntriesHelper(fixedLength), null, rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - }); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - - // The fixed length array goes out of bounds when the RAB is resized. - assert.throws(TypeError, () => { - TestIterationAndResize(TypedArrayEntriesHelper(fixedLengthWithOffset), null, rab, 1, 3 * ctor.BYTES_PER_ELEMENT); - }); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTracking = new ctor(rab, 0); - TestIterationAndResize(TypedArrayEntriesHelper(lengthTracking), [ - [ - 0, - 0 - ], - [ - 1, - 2 - ], - [ - 2, - 4 - ] - ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - } - for (let ctor of ctors) { - const rab = CreateRabForTest(ctor); - const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); - TestIterationAndResize(TypedArrayEntriesHelper(lengthTrackingWithOffset), [ - [ - 0, - 4 - ], - [ - 1, - 6 - ] - ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); - } + // The fixed length array goes out of bounds when the RAB is resized. + assert.throws(TypeError, () => { + TestIterationAndResize(TypedArrayEntriesHelper(fixedLength), null, rab, 2, 3 * ctor.BYTES_PER_ELEMENT); + }); } +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); -EntriesShrinkMidIteration(); + // The fixed length array goes out of bounds when the RAB is resized. + assert.throws(TypeError, () => { + TestIterationAndResize(TypedArrayEntriesHelper(fixedLengthWithOffset), null, rab, 1, 3 * ctor.BYTES_PER_ELEMENT); + }); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTracking = new ctor(rab, 0); + TestIterationAndResize(TypedArrayEntriesHelper(lengthTracking), [ + [ + 0, + 0 + ], + [ + 1, + 2 + ], + [ + 2, + 4 + ] + ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); +} +for (let ctor of ctors) { + const rab = CreateRabForTest(ctor); + const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT); + TestIterationAndResize(TypedArrayEntriesHelper(lengthTrackingWithOffset), [ + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], rab, 2, 3 * ctor.BYTES_PER_ELEMENT); +} diff --git a/test/built-ins/TypedArray/prototype/entries/resizable-buffer.js b/test/built-ins/TypedArray/prototype/entries/resizable-buffer.js index e6fa66ce27b..cb2e42f6b9a 100644 --- a/test/built-ins/TypedArray/prototype/entries/resizable-buffer.js +++ b/test/built-ins/TypedArray/prototype/entries/resizable-buffer.js @@ -25,160 +25,156 @@ function ValuesFromTypedArrayEntries(ta) { return result; } -function TestEntries() { - for (let ctor of ctors) { - const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); - const fixedLength = new ctor(rab, 0, 4); - const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); - const lengthTracking = new ctor(rab, 0); - const lengthTrackingWithOffset = new ctor(rab, 2 * 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); - } - - // Orig. array: [0, 2, 4, 6] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, ...] << lengthTracking - // [4, 6, ...] << lengthTrackingWithOffset - - assert.compareArray(ValuesFromTypedArrayEntries(fixedLength), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(fixedLengthWithOffset), [ - 4, - 6 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [ - 4, - 6 - ]); - - // Shrink so that fixed length TAs go out of bounds. - rab.resize(3 * ctor.BYTES_PER_ELEMENT); - - // Orig. array: [0, 2, 4] - // [0, 2, 4, ...] << lengthTracking - // [4, ...] << lengthTrackingWithOffset - - // TypedArray.prototype.{entries, keys, values} throw right away when - // called. Array.prototype.{entries, keys, values} don't throw, but when - // we try to iterate the returned ArrayIterator, that throws. - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLength); - }); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLengthWithOffset); - }); - - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ - 0, - 2, - 4 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [4]); - - // Shrink so that the TAs with offset go out of bounds. - rab.resize(1 * ctor.BYTES_PER_ELEMENT); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLength); - }); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLengthWithOffset); - }); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(lengthTrackingWithOffset); - }); - - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(lengthTrackingWithOffset)); - }); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [0]); - - // Shrink to zero. - rab.resize(0); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLength); - }); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(fixedLengthWithOffset); - }); - assert.throws(TypeError, () => { - TypedArrayEntriesHelper(lengthTrackingWithOffset); - }); - - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLength)); - }); - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); - }); - assert.throws(TypeError, () => { - Array.from(TypedArrayEntriesHelper(lengthTrackingWithOffset)); - }); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), []); - - // Grow so that all TAs are back in-bounds. - rab.resize(6 * ctor.BYTES_PER_ELEMENT); - for (let i = 0; i < 6; ++i) { - WriteToTypedArray(taWrite, i, 2 * i); - } - - // Orig. array: [0, 2, 4, 6, 8, 10] - // [0, 2, 4, 6] << fixedLength - // [4, 6] << fixedLengthWithOffset - // [0, 2, 4, 6, 8, 10, ...] << lengthTracking - // [4, 6, 8, 10, ...] << lengthTrackingWithOffset - - assert.compareArray(ValuesFromTypedArrayEntries(fixedLength), [ - 0, - 2, - 4, - 6 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(fixedLengthWithOffset), [ - 4, - 6 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ - 0, - 2, - 4, - 6, - 8, - 10 - ]); - assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [ - 4, - 6, - 8, - 10 - ]); +for (let ctor of ctors) { + const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); + const fixedLength = new ctor(rab, 0, 4); + const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2); + const lengthTracking = new ctor(rab, 0); + const lengthTrackingWithOffset = new ctor(rab, 2 * 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); + } + + // Orig. array: [0, 2, 4, 6] + // [0, 2, 4, 6] << fixedLength + // [4, 6] << fixedLengthWithOffset + // [0, 2, 4, 6, ...] << lengthTracking + // [4, 6, ...] << lengthTrackingWithOffset + + assert.compareArray(ValuesFromTypedArrayEntries(fixedLength), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(fixedLengthWithOffset), [ + 4, + 6 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [ + 4, + 6 + ]); + + // Shrink so that fixed length TAs go out of bounds. + rab.resize(3 * ctor.BYTES_PER_ELEMENT); + + // Orig. array: [0, 2, 4] + // [0, 2, 4, ...] << lengthTracking + // [4, ...] << lengthTrackingWithOffset + + // TypedArray.prototype.{entries, keys, values} throw right away when + // called. Array.prototype.{entries, keys, values} don't throw, but when + // we try to iterate the returned ArrayIterator, that throws. + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLength); + }); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLengthWithOffset); + }); + + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ + 0, + 2, + 4 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [4]); + + // Shrink so that the TAs with offset go out of bounds. + rab.resize(1 * ctor.BYTES_PER_ELEMENT); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLength); + }); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLengthWithOffset); + }); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(lengthTrackingWithOffset); + }); + + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(lengthTrackingWithOffset)); + }); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [0]); + + // Shrink to zero. + rab.resize(0); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLength); + }); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(fixedLengthWithOffset); + }); + assert.throws(TypeError, () => { + TypedArrayEntriesHelper(lengthTrackingWithOffset); + }); + + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLength)); + }); + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(fixedLengthWithOffset)); + }); + assert.throws(TypeError, () => { + Array.from(TypedArrayEntriesHelper(lengthTrackingWithOffset)); + }); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), []); + + // Grow so that all TAs are back in-bounds. + rab.resize(6 * ctor.BYTES_PER_ELEMENT); + for (let i = 0; i < 6; ++i) { + WriteToTypedArray(taWrite, i, 2 * i); } -} -TestEntries(); + // Orig. array: [0, 2, 4, 6, 8, 10] + // [0, 2, 4, 6] << fixedLength + // [4, 6] << fixedLengthWithOffset + // [0, 2, 4, 6, 8, 10, ...] << lengthTracking + // [4, 6, 8, 10, ...] << lengthTrackingWithOffset + + assert.compareArray(ValuesFromTypedArrayEntries(fixedLength), [ + 0, + 2, + 4, + 6 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(fixedLengthWithOffset), [ + 4, + 6 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTracking), [ + 0, + 2, + 4, + 6, + 8, + 10 + ]); + assert.compareArray(ValuesFromTypedArrayEntries(lengthTrackingWithOffset), [ + 4, + 6, + 8, + 10 + ]); +}