| // Copyright 2022 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Flags: --allow-natives-syntax --js-staging |
| |
| 'use strict'; |
| |
| d8.file.execute('test/mjsunit/typedarray-helpers.js'); |
| |
| (function ArrayConcatDefault() { |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const lengthTracking = new ctor(gsab); |
| |
| const taWrite = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(taWrite, i, i + 1); |
| } |
| |
| // Orig. array: [1, 2, 3, 4] |
| // [1, 2, 3, 4, ...] << lengthTracking |
| |
| function helper(receiver, ...params) { |
| return ToNumbers(Array.prototype.concat.call(receiver, ...params)); |
| } |
| |
| // TypedArrays aren't concat spreadable. |
| assertEquals([lengthTracking, 5, 6, 7], |
| helper(lengthTracking, [5, 6], [7])); |
| |
| // Resizing doesn't matter since the TA is added as a single item. |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| assertEquals([lengthTracking, 5, 6, 7], |
| helper(lengthTracking, [5, 6], [7])); |
| } |
| })(); |
| |
| (function ArrayConcatConcatSpreadable() { |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const fixedLength = new ctor(gsab, 0, 4); |
| const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2); |
| const lengthTracking = new ctor(gsab, 0); |
| const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT); |
| fixedLength[Symbol.isConcatSpreadable] = true; |
| fixedLengthWithOffset[Symbol.isConcatSpreadable] = true; |
| lengthTracking[Symbol.isConcatSpreadable] = true; |
| lengthTrackingWithOffset[Symbol.isConcatSpreadable] = true; |
| |
| const taWrite = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(taWrite, i, i + 1); |
| } |
| |
| // Orig. array: [1, 2, 3, 4] |
| // [1, 2, 3, 4] << fixedLength |
| // [3, 4] << fixedLengthWithOffset |
| // [1, 2, 3, 4, ...] << lengthTracking |
| // [3, 4, ...] << lengthTrackingWithOffset |
| |
| function helper(receiver, ...params) { |
| return ToNumbers(Array.prototype.concat.call(receiver, ...params)); |
| } |
| |
| assertEquals([0, 1, 2, 3, 4, 5, 6], helper([0], fixedLength, [5, 6])); |
| assertEquals([0, 3, 4, 5, 6], helper([0], fixedLengthWithOffset, [5, 6])); |
| assertEquals([0, 1, 2, 3, 4, 5, 6], helper([0], lengthTracking, [5, 6])); |
| assertEquals([0, 3, 4, 5, 6], |
| helper([0], lengthTrackingWithOffset, [5, 6])); |
| |
| // Grow. |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| for (let i = 0; i < 6; ++i) { |
| WriteToTypedArray(taWrite, i, i + 1); |
| } |
| // Orig. array: [1, 2, 3, 4, 5, 6] |
| // [1, 2, 3, 4] << fixedLength |
| // [3, 4] << fixedLengthWithOffset |
| // [1, 2, 3, 4, 5, 6, ...] << lengthTracking |
| // [3, 4, 5, 6, ...] << lengthTrackingWithOffset |
| |
| assertEquals([0, 1, 2, 3, 4, 7, 8], helper([0], fixedLength, [7, 8])); |
| assertEquals([0, 3, 4, 7, 8], helper([0], fixedLengthWithOffset, [7, 8])); |
| assertEquals([0, 1, 2, 3, 4, 5, 6, 7, 8], |
| helper([0], lengthTracking, [7, 8])); |
| assertEquals([0, 3, 4, 5, 6, 7, 8], |
| helper([0], lengthTrackingWithOffset, [7, 8])); |
| } |
| })(); |
| |
| // Hand-crafted test to hit a somewhat esoteric code path in Array.p.concat. |
| (function ArrayConcatConcatDictionaryElementsProto() { |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const fixedLength = new ctor(gsab, 0, 4); |
| const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2); |
| const lengthTracking = new ctor(gsab, 0); |
| const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT); |
| |
| const taWrite = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(taWrite, i, i + 1); |
| } |
| |
| // Orig. array: [1, 2, 3, 4] |
| // [1, 2, 3, 4] << fixedLength |
| // [3, 4] << fixedLengthWithOffset |
| // [1, 2, 3, 4, ...] << lengthTracking |
| // [3, 4, ...] << lengthTrackingWithOffset |
| |
| const largeIndex = 5000; |
| function helper(ta) { |
| const newArray = []; |
| newArray[largeIndex] = 11111; // Force dictionary mode. |
| assertTrue(%HasDictionaryElements(newArray)); |
| newArray.__proto__ = ta; |
| return Array.prototype.concat.call([], newArray); |
| } |
| |
| function assertArrayContents(expectedStart, array) { |
| for (let i = 0; i < expectedStart.length; ++i) { |
| assertEquals(expectedStart[i], Number(array[i])); |
| } |
| assertEquals(largeIndex + 1, array.length); |
| // Don't check every index to keep the test run time reasonable. |
| for (let i = expectedStart.length; i < largeIndex - 1; i += 153) { |
| assertEquals(undefined, array[i]); |
| } |
| assertEquals(11111, Number(array[largeIndex])); |
| } |
| |
| assertArrayContents([1, 2, 3, 4], helper(fixedLength)); |
| assertArrayContents([3, 4], helper(fixedLengthWithOffset)); |
| assertArrayContents([1, 2, 3, 4], helper(lengthTracking)); |
| assertArrayContents([3, 4], helper(lengthTrackingWithOffset)); |
| |
| // Grow. |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| for (let i = 0; i < 6; ++i) { |
| WriteToTypedArray(taWrite, i, i + 1); |
| } |
| // Orig. array: [1, 2, 3, 4, 5, 6] |
| // [1, 2, 3, 4] << fixedLength |
| // [3, 4] << fixedLengthWithOffset |
| // [1, 2, 3, 4, 5, 6, ...] << lengthTracking |
| // [3, 4, 5, 6, ...] << lengthTrackingWithOffset |
| |
| assertArrayContents([1, 2, 3, 4], helper(fixedLength)); |
| assertArrayContents([3, 4], helper(fixedLengthWithOffset)); |
| assertArrayContents([1, 2, 3, 4, 5, 6], helper(lengthTracking)); |
| assertArrayContents([3, 4, 5, 6], helper(lengthTrackingWithOffset)); |
| } |
| })(); |
| |
| (function ArrayPushPopShiftUnshiftSplice() { |
| // These functions always fail since setting the length fails. |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const fixedLength = new ctor(gsab, 0, 4); |
| const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2); |
| const lengthTracking = new ctor(gsab, 0); |
| const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT); |
| |
| for (let func of [Array.prototype.push, Array.prototype.unshift, |
| Array.prototype.splice]) { |
| assertThrows(() => { |
| func.call(fixedLength, 0); }, TypeError); |
| assertThrows(() => { |
| func.call(fixedLengthWithOffset, 0); }, TypeError); |
| assertThrows(() => { |
| func.call(lengthTracking, 0); }, TypeError); |
| assertThrows(() => { |
| func.call(lengthTrackingWithOffset, 0); }, TypeError); |
| } |
| |
| for (let func of [Array.prototype.pop, Array.prototype.shift]) { |
| assertThrows(() => { |
| func.call(fixedLength); }, TypeError); |
| assertThrows(() => { |
| func.call(fixedLengthWithOffset); }, TypeError); |
| assertThrows(() => { |
| func.call(lengthTracking); }, TypeError); |
| assertThrows(() => { |
| func.call(lengthTrackingWithOffset); }, TypeError); |
| } |
| } |
| })(); |
| |
| (function ArraySlice() { |
| const sliceHelper = ArraySliceHelper; |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const fixedLength = new ctor(gsab, 0, 4); |
| const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2); |
| const lengthTracking = new ctor(gsab, 0); |
| const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT); |
| |
| // Write some data into the array. |
| const taWrite = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(taWrite, i, i); |
| } |
| |
| const fixedLengthSlice = sliceHelper(fixedLength); |
| assertEquals([0, 1, 2, 3], ToNumbers(fixedLengthSlice)); |
| |
| const fixedLengthWithOffsetSlice = sliceHelper(fixedLengthWithOffset); |
| assertEquals([2, 3], ToNumbers(fixedLengthWithOffsetSlice)); |
| |
| const lengthTrackingSlice = sliceHelper(lengthTracking); |
| assertEquals([0, 1, 2, 3], ToNumbers(lengthTrackingSlice)); |
| |
| const lengthTrackingWithOffsetSlice = sliceHelper(lengthTrackingWithOffset); |
| assertEquals([2, 3], ToNumbers(lengthTrackingWithOffsetSlice)); |
| |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| assertEquals([0, 1, 2, 3], ToNumbers(sliceHelper(fixedLength))); |
| assertEquals([2, 3], ToNumbers(sliceHelper(fixedLengthWithOffset))); |
| assertEquals([0, 1, 2, 3, 0, 0], ToNumbers(sliceHelper(lengthTracking))); |
| assertEquals([2, 3, 0, 0], |
| ToNumbers(sliceHelper(lengthTrackingWithOffset))); |
| |
| // Verify that the previously created slices aren't affected by the growing. |
| assertEquals([0, 1, 2, 3], ToNumbers(fixedLengthSlice)); |
| assertEquals([2, 3], ToNumbers(fixedLengthWithOffsetSlice)); |
| assertEquals([0, 1, 2, 3], ToNumbers(lengthTrackingSlice)); |
| assertEquals([2, 3], ToNumbers(lengthTrackingWithOffsetSlice)); |
| } |
| })(); |
| |
| (function ArrayFlatFlatMapFrom() { |
| const flatHelper = ArrayFlatHelper; |
| const flatMapHelper = ArrayFlatMapHelper; |
| |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const fixedLength = new ctor(gsab, 0, 4); |
| const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2); |
| const lengthTracking = new ctor(gsab, 0); |
| const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT); |
| |
| // Write some data into the array. |
| const taWrite = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(taWrite, i, i); |
| } |
| |
| function mapper(n) { |
| if (typeof n == 'bigint') { |
| return n + 1n; |
| } |
| return n + 1; |
| } |
| |
| const fixedLengthFlat = flatHelper(fixedLength); |
| assertEquals([0, 1, 2, 3], ToNumbers(fixedLengthFlat)); |
| assertTrue(fixedLengthFlat instanceof Array); |
| |
| const fixedLengthWithOffsetFlat = flatHelper(fixedLengthWithOffset); |
| assertEquals([2, 3], ToNumbers(fixedLengthWithOffsetFlat)); |
| assertTrue(fixedLengthWithOffsetFlat instanceof Array); |
| |
| const lengthTrackingFlat = flatHelper(lengthTracking); |
| assertEquals([0, 1, 2, 3], ToNumbers(lengthTrackingFlat)); |
| assertTrue(lengthTrackingFlat instanceof Array); |
| |
| const lengthTrackingWithOffsetFlat = flatHelper(lengthTrackingWithOffset); |
| assertEquals([2, 3], ToNumbers(lengthTrackingWithOffsetFlat)); |
| assertTrue(lengthTrackingWithOffsetFlat instanceof Array); |
| |
| assertEquals([1, 2, 3, 4], |
| ToNumbers(flatMapHelper(fixedLength, mapper))); |
| assertEquals([3, 4], |
| ToNumbers(flatMapHelper(fixedLengthWithOffset, mapper))); |
| assertEquals([1, 2, 3, 4], |
| ToNumbers(flatMapHelper(lengthTracking, mapper))); |
| assertEquals([3, 4], |
| ToNumbers(flatMapHelper(lengthTrackingWithOffset, mapper))); |
| |
| assertEquals([0, 1, 2, 3], ToNumbers(Array.from(fixedLength))); |
| assertEquals([2, 3], ToNumbers(Array.from(fixedLengthWithOffset))); |
| assertEquals([0, 1, 2, 3], ToNumbers(Array.from(lengthTracking))); |
| assertEquals([2, 3], ToNumbers(Array.from(lengthTrackingWithOffset))); |
| |
| // Grow. New memory is zeroed. |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| assertEquals([0, 1, 2, 3], ToNumbers(flatHelper(fixedLength))); |
| assertEquals([2, 3], ToNumbers(flatHelper(fixedLengthWithOffset))); |
| assertEquals([0, 1, 2, 3, 0, 0], ToNumbers(flatHelper(lengthTracking))); |
| assertEquals([2, 3, 0, 0], |
| ToNumbers(flatHelper(lengthTrackingWithOffset))); |
| |
| assertEquals([1, 2, 3, 4], |
| ToNumbers(flatMapHelper(fixedLength, mapper))); |
| assertEquals([3, 4], |
| ToNumbers(flatMapHelper(fixedLengthWithOffset, mapper))); |
| assertEquals([1, 2, 3, 4, 1, 1], |
| ToNumbers(flatMapHelper(lengthTracking, mapper))); |
| assertEquals([3, 4, 1, 1], |
| ToNumbers(flatMapHelper(lengthTrackingWithOffset, mapper))); |
| |
| assertEquals([0, 1, 2, 3], ToNumbers(Array.from(fixedLength))); |
| assertEquals([2, 3], ToNumbers(Array.from(fixedLengthWithOffset))); |
| assertEquals([0, 1, 2, 3, 0, 0], ToNumbers(Array.from(lengthTracking))); |
| assertEquals([2, 3, 0, 0], ToNumbers(Array.from(lengthTrackingWithOffset))); |
| } |
| })(); |
| |
| (function ArrayFlatParameterConversionGrows() { |
| const flatHelper = ArrayFlatHelper; |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const lengthTracking = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(lengthTracking, i, i + 1); |
| } |
| const evil = { valueOf: () => { gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| return 0; }}; |
| // The original length is used. |
| assertEquals([1, 2, 3, 4], ToNumbers(flatHelper(lengthTracking, evil))); |
| assertEquals(6 * ctor.BYTES_PER_ELEMENT, gsab.byteLength); |
| } |
| })(); |
| |
| (function ArrayFlatMapMapperGrows() { |
| const flatMapHelper = ArrayFlatMapHelper; |
| |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const lengthTracking = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(lengthTracking, i, i + 1); |
| } |
| function mapper(n) { |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| return n; |
| } |
| assertEquals([1, 2, 3, 4], ToNumbers(flatMapHelper(lengthTracking, mapper))); |
| assertEquals(6 * ctor.BYTES_PER_ELEMENT, gsab.byteLength); |
| } |
| })(); |
| |
| (function ArrayFromMapperGrows() { |
| for (let ctor of ctors) { |
| const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, |
| 8 * ctor.BYTES_PER_ELEMENT); |
| const lengthTracking = new ctor(gsab); |
| for (let i = 0; i < 4; ++i) { |
| WriteToTypedArray(lengthTracking, i, i + 1); |
| } |
| function mapper(n) { |
| gsab.grow(6 * ctor.BYTES_PER_ELEMENT); |
| return n; |
| } |
| // We keep iterating after the TA has grown. |
| assertEquals([1, 2, 3, 4, 0, 0], |
| ToNumbers(Array.from(lengthTracking, mapper))); |
| assertEquals(6 * ctor.BYTES_PER_ELEMENT, gsab.byteLength); |
| } |
| })(); |
