From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- js/src/tests/non262/extensions/sharedtypedarray.js | 273 +++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 js/src/tests/non262/extensions/sharedtypedarray.js (limited to 'js/src/tests/non262/extensions/sharedtypedarray.js') diff --git a/js/src/tests/non262/extensions/sharedtypedarray.js b/js/src/tests/non262/extensions/sharedtypedarray.js new file mode 100644 index 0000000000..56187d29f5 --- /dev/null +++ b/js/src/tests/non262/extensions/sharedtypedarray.js @@ -0,0 +1,273 @@ +// |reftest| skip-if(!xulRuntime.shell) +/* -*- Mode: js2; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * Any copyright is dedicated to the Public Domain. + * https://creativecommons.org/publicdomain/zero/1.0/ + */ + +// Minimal test cases. Note that on 64-bit a SharedArrayBuffer is +// very expensive under these rules - a 4GB area is reserved for it. +// So don't go allocating a ton of them. +// +// These tests cannot test that sharing works across workers. There +// are or will be tests, in dom/workers, that do that. + +var b; + +function testSharedArrayBuffer() { + b = new SharedArrayBuffer("4096"); // Test string conversion, too + assertEq(b instanceof SharedArrayBuffer, true); + assertEq(b.byteLength, 4096); + + b.fnord = "Hi there"; + assertEq(b.fnord, "Hi there"); + + SharedArrayBuffer.prototype.abracadabra = "no wishing for wishes!"; + assertEq(b.abracadabra, "no wishing for wishes!"); + + // SharedArrayBuffer is not a conversion operator, not even for instances of itself + assertThrowsInstanceOf(() => SharedArrayBuffer(b), TypeError); + + // can't convert any other object either + assertThrowsInstanceOf(() => SharedArrayBuffer({}), TypeError); + + // byteLength can be invoked as per normal, indirectly + assertEq(Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype,"byteLength").get.call(b), 4096); + + // however byteLength is not generic + assertThrowsInstanceOf(() => Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype,"byteLength").get.call({}), TypeError); + +} + +function testSharedTypedArray() { + var x1 = new Int8Array(b); + var x2 = new Int32Array(b); + + assertEq(ArrayBuffer.isView(x1), true); // ArrayBuffer.isView() works even if the buffer is a SharedArrayBuffer + assertEq(ArrayBuffer.isView(x2), true); + assertEq(ArrayBuffer.isView({}), false); + + assertEq(x1.buffer, b); + assertEq(x2.buffer, b); + + assertEq(x1.byteLength, b.byteLength); + assertEq(x2.byteLength, b.byteLength); + + assertEq(x1.byteOffset, 0); + assertEq(x2.byteOffset, 0); + + assertEq(x1.length, b.byteLength); + assertEq(x2.length, b.byteLength / 4); + + var x3 = new Int8Array(b, 20); + assertEq(x3.length, b.byteLength - 20); + assertEq(x3.byteOffset, 20); + + var x3 = new Int32Array(b, 20, 10); + assertEq(x3.length, 10); + assertEq(x3.byteOffset, 20); + + // Mismatched type + assertThrowsInstanceOf(() => Int8Array(x2), TypeError); + + // Unconvertable object + assertThrowsInstanceOf(() => Int8Array({}), TypeError); + + // negative start + assertThrowsInstanceOf(() => new Int8Array(b, -7), RangeError); + + // not congruent mod element size + assertThrowsInstanceOf(() => new Int32Array(b, 3), RangeError); + + // start out of range + assertThrowsInstanceOf(() => new Int32Array(b, 4104), RangeError); + + // end out of range + assertThrowsInstanceOf(() => new Int32Array(b, 4092, 2), RangeError); + + // Views alias the storage + x2[0] = -1; + assertEq(x1[0], -1); + x1[0] = 1; + x1[1] = 1; + x1[2] = 1; + x1[3] = 1; + assertEq(x2[0], 0x01010101); + + assertEq(x2[5], 0); + x3[0] = -1; + assertEq(x2[5], -1); + + // Out-of-range accesses yield undefined + assertEq(x2[1023], 0); + assertEq(x2[1024], undefined); + assertEq(x2[2047], undefined); +} + +function testSharedTypedArrayMethods() { + var v = new Int32Array(b); + for ( var i=0 ; i < v.length ; i++ ) + v[i] = i; + + // Rudimentary tests - they don't test any boundary conditions + + // subarray + var w = v.subarray(10, 20); + assertEq(w.length, 10); + for ( var i=0 ; i < w.length ; i++ ) + assertEq(w[i], v[i+10]); + for ( var i=0 ; i < w.length ; i++ ) + w[i] = -w[i]; + for ( var i=0 ; i < w.length ; i++ ) + assertEq(w[i], v[i+10]); + + // copyWithin + for ( var i=0 ; i < v.length ; i++ ) + v[i] = i; + v.copyWithin(10, 20, 30); + for ( var i=0 ; i < 10 ; i++ ) + assertEq(v[i], i); + for ( var i=10 ; i < 20 ; i++ ) + assertEq(v[i], v[i+10]); + + // set + for ( var i=0 ; i < v.length ; i++ ) + v[i] = i; + v.set([-1,-2,-3,-4,-5,-6,-7,-8,-9,-10], 5); + for ( var i=5 ; i < 15 ; i++ ) + assertEq(v[i], -i+4); + + // In the following two cases the two arrays will reference the same buffer, + // so there will be an overlapping copy. + // + // Case 1: Read from lower indices than are written + v.set(v.subarray(0, 7), 1); + assertEq(v[0], 0); + assertEq(v[1], 0); + assertEq(v[2], 1); + assertEq(v[3], 2); + assertEq(v[4], 3); + assertEq(v[5], 4); + assertEq(v[6], -1); + assertEq(v[7], -2); + assertEq(v[8], -4); + assertEq(v[9], -5); + + // Case 2: Read from higher indices than are written + v.set(v.subarray(1, 5), 0); + assertEq(v[0], 0); + assertEq(v[1], 1); + assertEq(v[2], 2); + assertEq(v[3], 3); + assertEq(v[4], 3); + assertEq(v[5], 4); + assertEq(v[6], -1); + assertEq(v[7], -2); + assertEq(v[8], -4); + assertEq(v[9], -5); +} + +function testClone1() { + var sab1 = b; + var blob = serialize(sab1, [], {SharedArrayBuffer: 'allow'}); + var sab2 = deserialize(blob, {SharedArrayBuffer: 'allow'}); + if (typeof sharedAddress != "undefined") + assertEq(sharedAddress(sab1), sharedAddress(sab2)); +} + +function testClone2() { + var sab = b; + var ia1 = new Int32Array(sab); + var blob = serialize(ia1, [], {SharedArrayBuffer: 'allow'}); + var ia2 = deserialize(blob, {SharedArrayBuffer: 'allow'}); + assertEq(ia1.length, ia2.length); + assertEq(ia1.buffer instanceof SharedArrayBuffer, true); + if (typeof sharedAddress != "undefined") + assertEq(sharedAddress(ia1.buffer), sharedAddress(ia2.buffer)); + ia1[10] = 37; + assertEq(ia2[10], 37); +} + +// Serializing a SharedArrayBuffer should fail if we've set its flag to 'deny' or if +// the flag is bogus or if the flag is not set to 'allow' explicitly + +function testNoClone() { + // This just tests the API in serialize() + assertThrowsInstanceOf(() => serialize(b, [], {SharedArrayBuffer: false}), Error); + + // This tests the actual cloning functionality - should fail + assertThrowsInstanceOf(() => serialize(b, [], {SharedArrayBuffer: 'deny'}), TypeError); + + // This tests that cloning a SharedArrayBuffer is not allowed by default + assertThrowsInstanceOf(() => serialize(b), TypeError); + + // Ditto - should succeed + assertEq(typeof serialize(b, [], {SharedArrayBuffer: 'allow'}), "object"); + + let blob = serialize(b, [], {SharedArrayBuffer: 'allow'}); + // This just tests the API in deserialize() + assertThrowsInstanceOf(() => deserialize(blob, {SharedArrayBuffer: false}), Error); + + // This tests the actual cloning functionality - should fail + assertThrowsInstanceOf(() => deserialize(blob, {SharedArrayBuffer: 'deny'}), TypeError); + + // This tests that cloning a SharedArrayBuffer is not allowed by default + assertThrowsInstanceOf(() => deserialize(blob), TypeError); + + // Ditto - should succeed + assertEq(typeof deserialize(blob, {SharedArrayBuffer: 'allow'}), "object"); +} + +function testRedundantTransfer() { + // Throws TypeError in the shell, DataCloneError in the browser. + assertThrowsInstanceOf(() => { + var sab1 = b; + var blob = serialize(sab1, [sab1], {SharedArrayBuffer: 'allow'}); + }, TypeError); +} + +function testApplicable() { + var sab = b; + var x; + + // Just make sure we can create all the view types on shared memory. + + x = new Int32Array(sab); + assertEq(x.length, sab.byteLength / Int32Array.BYTES_PER_ELEMENT); + x = new Uint32Array(sab); + assertEq(x.length, sab.byteLength / Uint32Array.BYTES_PER_ELEMENT); + + x = new Int16Array(sab); + assertEq(x.length, sab.byteLength / Int16Array.BYTES_PER_ELEMENT); + x = new Uint16Array(sab); + assertEq(x.length, sab.byteLength / Uint16Array.BYTES_PER_ELEMENT); + + x = new Int8Array(sab); + assertEq(x.length, sab.byteLength / Int8Array.BYTES_PER_ELEMENT); + x = new Uint8Array(sab); + assertEq(x.length, sab.byteLength / Uint8Array.BYTES_PER_ELEMENT); + + // Though the atomic operations are illegal on Uint8ClampedArray and the + // float arrays, they can still be used to create views on shared memory. + + x = new Uint8ClampedArray(sab); + assertEq(x.length, sab.byteLength / Uint8ClampedArray.BYTES_PER_ELEMENT); + + x = new Float32Array(sab); + assertEq(x.length, sab.byteLength / Float32Array.BYTES_PER_ELEMENT); + x = new Float64Array(sab); + assertEq(x.length, sab.byteLength / Float64Array.BYTES_PER_ELEMENT); +} + +if (this.SharedArrayBuffer) { + testSharedArrayBuffer(); + testSharedTypedArray(); + testSharedTypedArrayMethods(); + testClone1(); + testClone2(); + testNoClone(); + testRedundantTransfer(); + testApplicable(); +} + +reportCompare(0, 0, 'ok'); -- cgit v1.2.3