test/mjsunit/harmony/sharedarraybuffer.js - Issue 1136553006: Implement SharedArrayBuffer

Unified Diff: test/mjsunit/harmony/sharedarraybuffer.js

Issue 1136553006: Implement SharedArrayBuffer (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master

Patch Set: merge master Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: test/mjsunit/harmony/sharedarraybuffer.js

diff --git a/test/mjsunit/harmony/typedarrays.js b/test/mjsunit/harmony/sharedarraybuffer.js

similarity index 65%

copy from test/mjsunit/harmony/typedarrays.js

copy to test/mjsunit/harmony/sharedarraybuffer.js

index 70bd17e3382db1cdb115d5aae6e48cf9141bc82a..0a2f2850f2a31867b2e20de3c2dfd128cbe8c42b 100644

--- a/test/mjsunit/harmony/typedarrays.js

+++ b/test/mjsunit/harmony/sharedarraybuffer.js

@@ -1,4 +1,4 @@

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

@@ -25,13 +25,13 @@

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-// Flags: --harmony-tostring

+// Flags: --harmony-sharedarraybuffer

-// ArrayBuffer

+// SharedArrayBuffer

function TestByteLength(param, expectedByteLength) {

- var ab = new ArrayBuffer(param);

- assertSame(expectedByteLength, ab.byteLength);

+ var sab = new SharedArrayBuffer(param);

+ assertSame(expectedByteLength, sab.byteLength);

}

function TestArrayBufferCreation() {

@@ -43,137 +43,97 @@ function TestArrayBufferCreation() {

TestByteLength(0, 0);

- assertThrows(function() { new ArrayBuffer(-10); }, RangeError);

- assertThrows(function() { new ArrayBuffer(-2.567); }, RangeError);

+ assertThrows(function() { new SharedArrayBuffer(-10); }, RangeError);

+ assertThrows(function() { new SharedArrayBuffer(-2.567); }, RangeError);

/* TODO[dslomov]: Reenable the test

assertThrows(function() {

- var ab1 = new ArrayBuffer(0xFFFFFFFFFFFF)

+ var ab1 = new SharedArrayBuffer(0xFFFFFFFFFFFF)

}, RangeError);

- var ab = new ArrayBuffer();

- assertSame(0, ab.byteLength);

- assertEquals("[object ArrayBuffer]",

- Object.prototype.toString.call(ab));

+ var sab = new SharedArrayBuffer();

+ assertSame(0, sab.byteLength);

+ assertEquals("[object SharedArrayBuffer]",

+ Object.prototype.toString.call(sab));

}

TestArrayBufferCreation();

function TestByteLengthNotWritable() {

- var ab = new ArrayBuffer(1024);

- assertSame(1024, ab.byteLength);

+ var sab = new SharedArrayBuffer(1024);

+ assertSame(1024, sab.byteLength);

- assertThrows(function() { "use strict"; ab.byteLength = 42; }, TypeError);

+ assertThrows(function() { "use strict"; sab.byteLength = 42; }, TypeError);

}

TestByteLengthNotWritable();

-function TestSlice(expectedResultLen, initialLen, start, end) {

- var ab = new ArrayBuffer(initialLen);

- var a1 = new Uint8Array(ab);

- for (var i = 0; i < a1.length; i++) {

- a1[i] = 0xCA;

- }

- var slice = ab.slice(start, end);

- assertSame(expectedResultLen, slice.byteLength);

- var a2 = new Uint8Array(slice);

- for (var i = 0; i < a2.length; i++) {

- assertSame(0xCA, a2[i]);

- }

+function TestArrayBufferNoSlice() {

+ var sab = new SharedArrayBuffer(10);

+ assertEquals(undefined, sab.slice);

}

-function TestArrayBufferSlice() {

- var ab = new ArrayBuffer(1024);

- var ab1 = ab.slice(512, 1024);

- assertSame(512, ab1.byteLength);

- TestSlice(512, 1024, 512, 1024);

- TestSlice(512, 1024, 512);

- TestSlice(0, 0, 1, 20);

- TestSlice(100, 100, 0, 100);

- TestSlice(100, 100, 0, 1000);

- TestSlice(0, 100, 5, 1);

- TestSlice(1, 100, -11, -10);

- TestSlice(9, 100, -10, 99);

- TestSlice(0, 100, -10, 80);

- TestSlice(10, 100, 80, -10);

+TestArrayBufferNoSlice();

- TestSlice(10, 100, 90, "100");

- TestSlice(10, 100, "90", "100");

+// Typed arrays using SharedArrayBuffers

- TestSlice(0, 100, 90, "abc");

- TestSlice(10, 100, "abc", 10);

+// TODO(binji): how many of these tests are necessary if there are no new

+// TypedArray types?

- TestSlice(10, 100, 0.96, 10.96);

- TestSlice(10, 100, 0.96, 10.01);

- TestSlice(10, 100, 0.01, 10.01);

- TestSlice(10, 100, 0.01, 10.96);

- TestSlice(10, 100, 90);

- TestSlice(10, 100, -10);

+function MakeSharedTypedArray(constr, numElements) {

+ var sab = new SharedArrayBuffer(constr.BYTES_PER_ELEMENT * numElements);

+ return new constr(sab);

}

-TestArrayBufferSlice();

-// Typed arrays

function TestTypedArray(constr, elementSize, typicalElement) {

assertSame(elementSize, constr.BYTES_PER_ELEMENT);

- var ab = new ArrayBuffer(256*elementSize);

+ var sab = new SharedArrayBuffer(256*elementSize);

var a0 = new constr(30);

assertEquals("[object " + constr.name + "]",

Object.prototype.toString.call(a0));

- assertTrue(ArrayBuffer.isView(a0));

+ // TODO(binji): Should this return false here? It is a view, but it doesn't

+ // view a SharedArrayBuffer...

+ assertTrue(SharedArrayBuffer.isView(a0));

assertSame(elementSize, a0.BYTES_PER_ELEMENT);

assertSame(30, a0.length);

assertSame(30*elementSize, a0.byteLength);

assertSame(0, a0.byteOffset);

assertSame(30*elementSize, a0.buffer.byteLength);

- var aLen0 = new constr(0);

- assertSame(elementSize, aLen0.BYTES_PER_ELEMENT);

- assertSame(0, aLen0.length);

- assertSame(0, aLen0.byteLength);

- assertSame(0, aLen0.byteOffset);

- assertSame(0, aLen0.buffer.byteLength);

- var aOverBufferLen0 = new constr(ab, 128*elementSize, 0);

- assertSame(ab, aOverBufferLen0.buffer);

+ var aOverBufferLen0 = new constr(sab, 128*elementSize, 0);

+ assertSame(sab, aOverBufferLen0.buffer);

assertSame(elementSize, aOverBufferLen0.BYTES_PER_ELEMENT);

assertSame(0, aOverBufferLen0.length);

assertSame(0, aOverBufferLen0.byteLength);

assertSame(128*elementSize, aOverBufferLen0.byteOffset);

- var a1 = new constr(ab, 128*elementSize, 128);

- assertSame(ab, a1.buffer);

+ var a1 = new constr(sab, 128*elementSize, 128);

+ assertSame(sab, a1.buffer);

assertSame(elementSize, a1.BYTES_PER_ELEMENT);

assertSame(128, a1.length);

assertSame(128*elementSize, a1.byteLength);

assertSame(128*elementSize, a1.byteOffset);

- var a2 = new constr(ab, 64*elementSize, 128);

- assertSame(ab, a2.buffer);

+ var a2 = new constr(sab, 64*elementSize, 128);

+ assertSame(sab, a2.buffer);

assertSame(elementSize, a2.BYTES_PER_ELEMENT);

assertSame(128, a2.length);

assertSame(128*elementSize, a2.byteLength);

assertSame(64*elementSize, a2.byteOffset);

- var a3 = new constr(ab, 192*elementSize);

- assertSame(ab, a3.buffer);

+ var a3 = new constr(sab, 192*elementSize);

+ assertSame(sab, a3.buffer);

assertSame(64, a3.length);

assertSame(64*elementSize, a3.byteLength);

assertSame(192*elementSize, a3.byteOffset);

- var a4 = new constr(ab);

- assertSame(ab, a4.buffer);

+ var a4 = new constr(sab);

+ assertSame(sab, a4.buffer);

assertSame(256, a4.length);

assertSame(256*elementSize, a4.byteLength);

assertSame(0, a4.byteOffset);

@@ -208,21 +168,21 @@ function TestTypedArray(constr, elementSize, typicalElement) {

assertSame(typicalElement, a4[i]);

}

- var aAtTheEnd = new constr(ab, 256*elementSize);

+ var aAtTheEnd = new constr(sab, 256*elementSize);

assertSame(elementSize, aAtTheEnd.BYTES_PER_ELEMENT);

assertSame(0, aAtTheEnd.length);

assertSame(0, aAtTheEnd.byteLength);

assertSame(256*elementSize, aAtTheEnd.byteOffset);

- assertThrows(function () { new constr(ab, 257*elementSize); }, RangeError);

+ assertThrows(function () { new constr(sab, 257*elementSize); }, RangeError);

assertThrows(

- function () { new constr(ab, 128*elementSize, 192); },

+ function () { new constr(sab, 128*elementSize, 192); },

RangeError);

if (elementSize !== 1) {

- assertThrows(function() { new constr(ab, 128*elementSize - 1, 10); },

+ assertThrows(function() { new constr(sab, 128*elementSize - 1, 10); },

RangeError);

- var unalignedArrayBuffer = new ArrayBuffer(10*elementSize + 1);

+ var unalignedArrayBuffer = new SharedArrayBuffer(10*elementSize + 1);

var goodArray = new constr(unalignedArrayBuffer, 0, 10);

assertSame(10, goodArray.length);

assertSame(10*elementSize, goodArray.byteLength);

@@ -231,28 +191,7 @@ function TestTypedArray(constr, elementSize, typicalElement) {

RangeError);

}

- var aFromString = new constr("30");

- assertSame(elementSize, aFromString.BYTES_PER_ELEMENT);

- assertSame(30, aFromString.length);

- assertSame(30*elementSize, aFromString.byteLength);

- assertSame(0, aFromString.byteOffset);

- assertSame(30*elementSize, aFromString.buffer.byteLength);

- var jsArray = [];

- for (i = 0; i < 30; i++) {

- jsArray.push(typicalElement);

- }

- var aFromArray = new constr(jsArray);

- assertSame(elementSize, aFromArray.BYTES_PER_ELEMENT);

- assertSame(30, aFromArray.length);

- assertSame(30*elementSize, aFromArray.byteLength);

- assertSame(0, aFromArray.byteOffset);

- assertSame(30*elementSize, aFromArray.buffer.byteLength);

- for (i = 0; i < 30; i++) {

- assertSame(typicalElement, aFromArray[i]);

- }

- var abLen0 = new ArrayBuffer(0);

+ var abLen0 = new SharedArrayBuffer(0);

var aOverAbLen0 = new constr(abLen0);

assertSame(abLen0, aOverAbLen0.buffer);

assertSame(elementSize, aOverAbLen0.BYTES_PER_ELEMENT);

@@ -260,13 +199,7 @@ function TestTypedArray(constr, elementSize, typicalElement) {

assertSame(0, aOverAbLen0.byteLength);

assertSame(0, aOverAbLen0.byteOffset);

- var aNoParam = new constr();

- assertSame(elementSize, aNoParam.BYTES_PER_ELEMENT);

- assertSame(0, aNoParam.length);

- assertSame(0, aNoParam.byteLength);

- assertSame(0, aNoParam.byteOffset);

- var a = new constr(ab, 64*elementSize, 128);

+ var a = new constr(sab, 64*elementSize, 128);

assertEquals("[object " + constr.name + "]",

Object.prototype.toString.call(a));

var desc = Object.getOwnPropertyDescriptor(

@@ -288,9 +221,10 @@ TestTypedArray(Float32Array, 4, 0.5);

TestTypedArray(Float64Array, 8, 0.5);

TestTypedArray(Uint8ClampedArray, 1, 0xFF);

-function SubarrayTestCase(constructor, item, expectedResultLen, expectedStartIndex,

- initialLen, start, end) {

- var a = new constructor(initialLen);

+function SubarrayTestCase(constructor, item, expectedResultLen,

+ expectedStartIndex, initialLen, start, end) {

+ var a = MakeSharedTypedArray(constructor, initialLen);

var s = a.subarray(start, end);

assertSame(constructor, s.constructor);

assertSame(expectedResultLen, s.length);

@@ -328,11 +262,6 @@ function TestSubArray(constructor, item) {

SubarrayTestCase(constructor, item, 10,90, 100, 90);

SubarrayTestCase(constructor, item, 10,90, 100, -10);

- var method = constructor.prototype.subarray;

- method.call(new constructor(100), 0, 100);

- var o = {};

- assertThrows(function() { method.call(o, 0, 100); }, TypeError);

}

TestSubArray(Uint8Array, 0xFF);

@@ -346,7 +275,7 @@ TestSubArray(Float64Array, 0.5);

TestSubArray(Uint8ClampedArray, 0xFF);

function TestTypedArrayOutOfRange(constructor, value, result) {

- var a = new constructor(1);

+ var a = MakeSharedTypedArray(constructor, 1);

a[0] = value;

assertSame(result, a[0]);

}

@@ -385,7 +314,7 @@ function TestPropertyTypeChecks(constructor) {

assertThrows(function() {d.get.call(o);}, TypeError);

for (var i = 0; i < typedArrayConstructors.length; i++) {

var ctor = typedArrayConstructors[i];

- var a = new ctor(10);

+ var a = MakeSharedTypedArray(ctor, 10);

if (ctor === constructor) {

d.get.call(a); // shouldn't throw

} else {

@@ -404,7 +333,6 @@ for(i = 0; i < typedArrayConstructors.length; i++) {

TestPropertyTypeChecks(typedArrayConstructors[i]);

}

function TestTypedArraySet() {

// Test array.set in different combinations.

@@ -414,29 +342,38 @@ function TestTypedArraySet() {

}

- var a11 = new Int16Array([1, 2, 3, 4, 0, -1])

- var a12 = new Uint16Array(15)

+ // SharedTypedArrays don't allow initialization via array-like

+ function initializeFromArray(constructor, array) {

+ var buffer = MakeSharedTypedArray(constructor, array.length);

+ for (var i = 0; i < array.length; ++i) {

+ buffer[i] = array[i];

+ }

+ return buffer;

+ }

+ var a11 = initializeFromArray(Int16Array, [1, 2, 3, 4, 0, -1])

+ var a12 = MakeSharedTypedArray(Uint16Array, 15);

a12.set(a11, 3)

assertArrayPrefix([0, 0, 0, 1, 2, 3, 4, 0, 0xffff, 0, 0], a12)

assertThrows(function(){ a11.set(a12) })

var a21 = [1, undefined, 10, NaN, 0, -1, {valueOf: function() {return 3}}]

- var a22 = new Int32Array(12)

+ var a22 = MakeSharedTypedArray(Int32Array, 12)

a22.set(a21, 2)

assertArrayPrefix([0, 0, 1, 0, 10, 0, 0, -1, 3, 0], a22)

- var a31 = new Float32Array([2, 4, 6, 8, 11, NaN, 1/0, -3])

+ var a31 = initializeFromArray(Float32Array, [2, 4, 6, 8, 11, NaN, 1/0, -3])

var a32 = a31.subarray(2, 6)

a31.set(a32, 4)

assertArrayPrefix([2, 4, 6, 8, 6, 8, 11, NaN], a31)

assertArrayPrefix([6, 8, 6, 8], a32)

- var a4 = new Uint8ClampedArray([3,2,5,6])

+ var a4 = initializeFromArray(Uint8ClampedArray, [3,2,5,6])

a4.set(a4)

assertArrayPrefix([3, 2, 5, 6], a4)

// Cases with overlapping backing store but different element sizes.

- var b = new ArrayBuffer(4)

+ var b = new SharedArrayBuffer(4)

var a5 = new Int16Array(b)

var a50 = new Int8Array(b)

var a51 = new Int8Array(b, 0, 2)

@@ -474,15 +411,15 @@ function TestTypedArraySet() {

assertArrayPrefix([0x000a, 0x000b], a5)

// Mixed types of same size.

- var a61 = new Float32Array([1.2, 12.3])

- var a62 = new Int32Array(2)

+ var a61 = initializeFromArray(Float32Array, [1.2, 12.3])

+ var a62 = MakeSharedTypedArray(Int32Array, 2)

a62.set(a61)

assertArrayPrefix([1, 12], a62)

a61.set(a62)

assertArrayPrefix([1, 12], a61)

// Invalid source

- var a = new Uint16Array(50);

+ var a = MakeSharedTypedArray(Uint16Array, 50);

var expected = [];

for (i = 0; i < 50; i++) {

a[i] = i;

@@ -500,7 +437,7 @@ function TestTypedArraySet() {

TestTypedArraySet();

function TestTypedArraysWithIllegalIndices() {

- var a = new Int32Array(100);

+ var a = MakeSharedTypedArray(Int32Array, 100);

a[-10] = 10;

assertEquals(undefined, a[-10]);

@@ -549,7 +486,7 @@ TestTypedArraysWithIllegalIndices();

function TestTypedArraysWithIllegalIndicesStrict() {

'use strict';

- var a = new Int32Array(100);

+ var a = MakeSharedTypedArray(Int32Array, 100);

a[-10] = 10;

assertEquals(undefined, a[-10]);

@@ -596,88 +533,6 @@ function TestTypedArraysWithIllegalIndicesStrict() {

TestTypedArraysWithIllegalIndicesStrict();

-// DataView

-function TestDataViewConstructor() {

- var ab = new ArrayBuffer(256);

- var d1 = new DataView(ab, 1, 255);

- assertTrue(ArrayBuffer.isView(d1));

- assertSame(ab, d1.buffer);

- assertSame(1, d1.byteOffset);

- assertSame(255, d1.byteLength);

- var d2 = new DataView(ab, 2);

- assertSame(ab, d2.buffer);

- assertSame(2, d2.byteOffset);

- assertSame(254, d2.byteLength);

- var d3 = new DataView(ab);

- assertSame(ab, d3.buffer);

- assertSame(0, d3.byteOffset);

- assertSame(256, d3.byteLength);

- var d3a = new DataView(ab, 1, 0);

- assertSame(ab, d3a.buffer);

- assertSame(1, d3a.byteOffset);

- assertSame(0, d3a.byteLength);

- var d3b = new DataView(ab, 256, 0);

- assertSame(ab, d3b.buffer);

- assertSame(256, d3b.byteOffset);

- assertSame(0, d3b.byteLength);

- var d3c = new DataView(ab, 256);

- assertSame(ab, d3c.buffer);

- assertSame(256, d3c.byteOffset);

- assertSame(0, d3c.byteLength);

- var d4 = new DataView(ab, 1, 3.1415926);

- assertSame(ab, d4.buffer);

- assertSame(1, d4.byteOffset);

- assertSame(3, d4.byteLength);

- // error cases

- assertThrows(function() { new DataView(ab, -1); }, RangeError);

- assertThrows(function() { new DataView(ab, 1, -1); }, RangeError);

- assertThrows(function() { new DataView(); }, TypeError);

- assertThrows(function() { new DataView([]); }, TypeError);

- assertThrows(function() { new DataView(ab, 257); }, RangeError);

- assertThrows(function() { new DataView(ab, 1, 1024); }, RangeError);

-TestDataViewConstructor();

-function TestDataViewPropertyTypeChecks() {

- var a = new DataView(new ArrayBuffer(10));

- function CheckProperty(name) {

- var d = Object.getOwnPropertyDescriptor(DataView.prototype, name);

- var o = {}

- assertThrows(function() {d.get.call(o);}, TypeError);

- d.get.call(a); // shouldn't throw

- }

- CheckProperty("buffer");

- CheckProperty("byteOffset");

- CheckProperty("byteLength");

-TestDataViewPropertyTypeChecks();

-function TestDataViewToStringTag() {

- var a = new DataView(new ArrayBuffer(10));

- assertEquals("[object DataView]", Object.prototype.toString.call(a));

- var desc = Object.getOwnPropertyDescriptor(

- DataView.prototype, Symbol.toStringTag);

- assertTrue(desc.configurable);

- assertFalse(desc.enumerable);

- assertFalse(desc.writable);

- assertEquals("DataView", desc.value);

// General tests for properties

// Test property attribute [[Enumerable]]

@@ -692,11 +547,10 @@ function TestEnumerable(func, obj) {

if (obj)

assertArrayEquals([], props(obj));

}

-TestEnumerable(ArrayBuffer, new ArrayBuffer());

+TestEnumerable(ArrayBuffer, new SharedArrayBuffer());

for(i = 0; i < typedArrayConstructors.length; i++) {

TestEnumerable(typedArrayConstructors[i]);

}

-TestEnumerable(DataView, new DataView(new ArrayBuffer()));

// Test arbitrary properties on ArrayBuffer

function TestArbitrary(m) {

@@ -709,13 +563,14 @@ function TestArbitrary(m) {

TestProperty(m, 'foo' + i, 'bar' + i);

}

-TestArbitrary(new ArrayBuffer(256));

+TestArbitrary(new SharedArrayBuffer(256));

for(i = 0; i < typedArrayConstructors.length; i++) {

- TestArbitrary(new typedArrayConstructors[i](10));

+ TestArbitrary(MakeSharedTypedArray(typedArrayConstructors[i], 10));

}

-TestArbitrary(new DataView(new ArrayBuffer(256)));

// Test direct constructor call

-assertThrows(function() { ArrayBuffer(); }, TypeError);

-assertThrows(function() { DataView(new ArrayBuffer()); }, TypeError);

+assertThrows(function() { SharedArrayBuffer(); }, TypeError);

+for(i = 0; i < typedArrayConstructors.length; i++) {

+ assertThrows(function(i) { typedArrayConstructors[i](); }.bind(this, i),

+ TypeError);

« no previous file with comments | « test/cctest/test-api.cc ('k') | tools/gyp/v8.gyp » ('j') | no next file with comments »