1031 lines
30 KiB
HTML
1031 lines
30 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<script src="../../../resources/js-test.js"></script>
|
|
<script src="resources/webgl-test.js"></script>
|
|
<script src="resources/typed-array-test-cases.js"></script>
|
|
</head>
|
|
<body>
|
|
<div id="description"></div>
|
|
<div id="console"></div>
|
|
|
|
<script>
|
|
description("Verifies the functionality of the new array-like objects in the TypedArray spec");
|
|
|
|
var currentlyRunning = '';
|
|
var allPassed = true;
|
|
function running(str) {
|
|
currentlyRunning = str;
|
|
}
|
|
|
|
function output(str) {
|
|
debug(str);
|
|
}
|
|
|
|
function pass() {
|
|
testPassed(currentlyRunning);
|
|
}
|
|
|
|
function fail(str) {
|
|
allPassed = false;
|
|
var exc;
|
|
if (str)
|
|
exc = currentlyRunning + ': ' + str;
|
|
else
|
|
exc = currentlyRunning;
|
|
testFailed(exc);
|
|
}
|
|
|
|
function assertEq(prefix, expected, val) {
|
|
if (expected != val) {
|
|
var str = prefix + ': expected ' + expected + ', got ' + val;
|
|
throw str;
|
|
}
|
|
}
|
|
|
|
function assert(prefix, expected) {
|
|
if (!expected) {
|
|
var str = prefix + ': expected value / true';
|
|
throw str;
|
|
}
|
|
}
|
|
|
|
function printSummary() {
|
|
if (allPassed) {
|
|
debug("Test passed.");
|
|
} else {
|
|
debug("TEST FAILED");
|
|
}
|
|
}
|
|
|
|
var buffer;
|
|
var byteLength;
|
|
var subBuffer;
|
|
var subArray;
|
|
function testSlice() {
|
|
function test(subBuf, starts, size) {
|
|
byteLength = size;
|
|
subBuffer = eval(subBuf);
|
|
subArray = new Int8Array(subBuffer);
|
|
assertEq(subBuf, subBuffer.byteLength, byteLength);
|
|
for (var i = 0; i < size; ++i)
|
|
assertEq('Element ' + i, starts + i, subArray[i]);
|
|
}
|
|
|
|
try {
|
|
running('testSlice');
|
|
buffer = new ArrayBuffer(32);
|
|
var array = new Int8Array(buffer);
|
|
for (var i = 0; i < 32; ++i)
|
|
array[i] = i;
|
|
|
|
test("buffer.slice(0)", 0, 32);
|
|
test("buffer.slice(16)", 16, 16);
|
|
test("buffer.slice(24)", 24, 8);
|
|
test("buffer.slice(32)", 32, 0);
|
|
test("buffer.slice(40)", 32, 0);
|
|
test("buffer.slice(80)", 32, 0);
|
|
|
|
test("buffer.slice(-8)", 24, 8);
|
|
test("buffer.slice(-16)", 16, 16);
|
|
test("buffer.slice(-24)", 8, 24);
|
|
test("buffer.slice(-32)", 0, 32);
|
|
test("buffer.slice(-40)", 0, 32);
|
|
test("buffer.slice(-80)", 0, 32);
|
|
|
|
test("buffer.slice(0, 32)", 0, 32);
|
|
test("buffer.slice(0, 16)", 0, 16);
|
|
test("buffer.slice(8, 24)", 8, 16);
|
|
test("buffer.slice(16, 32)", 16, 16);
|
|
test("buffer.slice(24, 16)", 24, 0);
|
|
|
|
test("buffer.slice(16, -8)", 16, 8);
|
|
test("buffer.slice(-20, 30)", 12, 18);
|
|
|
|
test("buffer.slice(-8, -20)", 24, 0);
|
|
test("buffer.slice(-20, -8)", 12, 12);
|
|
test("buffer.slice(-40, 16)", 0, 16);
|
|
test("buffer.slice(-40, 40)", 0, 32);
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testInheritanceHierarchy() {
|
|
debug('test inheritance hierarchy of typed array views');
|
|
|
|
try {
|
|
var foo = ArrayBufferView;
|
|
testFailed("ArrayBufferView should be undefined but is defined");
|
|
} catch (e) {
|
|
testPassed('ArrayBufferView should be undefined and is');
|
|
}
|
|
|
|
shouldBe('new Uint8ClampedArray(1) instanceof Uint8Array', 'false');
|
|
}
|
|
|
|
//
|
|
// Tests for unsigned array variants
|
|
//
|
|
|
|
function testSetAndGet10To1(type, name) {
|
|
running('test ' + name + ' SetAndGet10To1');
|
|
try {
|
|
var array = new type(10);
|
|
for (var i = 0; i < 10; i++) {
|
|
array[i] = 10 - i;
|
|
}
|
|
for (var i = 0; i < 10; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructWithArrayOfUnsignedValues(type, name) {
|
|
running('test ' + name + ' ConstructWithArrayOfUnsignedValues');
|
|
try {
|
|
var array = new type([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
|
|
assertEq('Array length', 10, array.length);
|
|
for (var i = 0; i < 10; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructWithTypedArrayOfUnsignedValues(type, name) {
|
|
running('test ' + name + ' ConstructWithTypedArrayOfUnsignedValues');
|
|
try {
|
|
var tmp = new type([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
|
|
var array = new type(tmp);
|
|
assertEq('Array length', 10, array.length);
|
|
for (var i = 0; i < 10; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Tests for signed array variants
|
|
//
|
|
|
|
function testSetAndGetPos10ToNeg10(type, name) {
|
|
running('test ' + name + ' SetAndGetPos10ToNeg10');
|
|
try {
|
|
var array = new type(21);
|
|
for (var i = 0; i < 21; i++) {
|
|
array[i] = 10 - i;
|
|
}
|
|
for (var i = 0; i < 21; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructWithArrayOfSignedValues(type, name) {
|
|
running('test ' + name + ' ConstructWithArrayOfSignedValues');
|
|
try {
|
|
var array = new type([10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]);
|
|
assertEq('Array length', 21, array.length);
|
|
for (var i = 0; i < 21; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructWithTypedArrayOfSignedValues(type, name) {
|
|
running('test ' + name + ' ConstructWithTypedArrayOfSignedValues');
|
|
try {
|
|
var tmp = new type([10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]);
|
|
var array = new type(tmp);
|
|
assertEq('Array length', 21, array.length);
|
|
for (var i = 0; i < 21; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Test cases for integral types.
|
|
// Some JavaScript engines need separate copies of this code in order
|
|
// to exercise all of their optimized code paths.
|
|
//
|
|
|
|
function testIntegralArrayTruncationBehavior(type, name, unsigned) {
|
|
running('test integral array truncation behavior for ' + name);
|
|
|
|
var sourceData;
|
|
var expectedResults;
|
|
|
|
if (unsigned) {
|
|
sourceData = [0.6, 10.6, 0.2, 10.2, 10.5, 11.5];
|
|
if (type === Uint8ClampedArray) {
|
|
expectedResults = [1, 11, 0, 10, 10, 12];
|
|
} else {
|
|
expectedResults = [0, 10, 0, 10, 10, 11];
|
|
}
|
|
} else {
|
|
sourceData = [0.6, 10.6, -0.6, -10.6];
|
|
expectedResults = [0, 10, 0, -10];
|
|
}
|
|
|
|
var numIterations = 10;
|
|
var array = new type(numIterations);
|
|
|
|
// The code block in each of the case statements below is identical, but some
|
|
// JavaScript engines need separate copies in order to exercise all of
|
|
// their optimized code paths.
|
|
|
|
try {
|
|
switch (type) {
|
|
case Int8Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Int16Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Int32Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Uint8Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Uint8ClampedArray:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Uint16Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
case Uint32Array:
|
|
for (var ii = 0; ii < sourceData.length; ++ii) {
|
|
for (var jj = 0; jj < numIterations; ++jj) {
|
|
array[jj] = sourceData[ii];
|
|
assertEq('Storing ' + sourceData[ii], expectedResults[ii], array[jj]);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
fail("Unhandled type");
|
|
break;
|
|
}
|
|
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Test cases for both signed and unsigned types
|
|
//
|
|
|
|
function testGetWithOutOfRangeIndices(type, name) {
|
|
debug('Testing ' + name + ' GetWithOutOfRangeIndices');
|
|
// See below for declaration of this global variable
|
|
array = new type([2, 3]);
|
|
shouldBeUndefined("array[2]");
|
|
shouldBeUndefined("array[-1]");
|
|
shouldBeUndefined("array[0x20000000]");
|
|
}
|
|
|
|
function testOffsetsAndSizes(type, name, elementSizeInBytes) {
|
|
running('test ' + name + ' OffsetsAndSizes');
|
|
try {
|
|
var len = 10;
|
|
assertEq('type.BYTES_PER_ELEMENT', elementSizeInBytes, type.BYTES_PER_ELEMENT);
|
|
var array = new type(len);
|
|
assert('array.buffer', array.buffer);
|
|
assertEq('array.byteOffset', 0, array.byteOffset);
|
|
assertEq('array.length', len, array.length);
|
|
assertEq('array.byteLength', len * elementSizeInBytes, array.byteLength);
|
|
array = new type(array.buffer, elementSizeInBytes, len - 1);
|
|
assert('array.buffer', array.buffer);
|
|
assertEq('array.byteOffset', elementSizeInBytes, array.byteOffset);
|
|
assertEq('array.length', len - 1, array.length);
|
|
assertEq('array.byteLength', (len - 1) * elementSizeInBytes, array.byteLength);
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testSetFromTypedArray(type, name) {
|
|
running('test ' + name + ' SetFromTypedArray');
|
|
try {
|
|
var array = new type(10);
|
|
var array2 = new type(5);
|
|
for (var i = 0; i < 10; i++) {
|
|
assertEq('Element ' + i, 0, array[i]);
|
|
}
|
|
for (var i = 0; i < array2.length; i++) {
|
|
array2[i] = i;
|
|
}
|
|
array.set(array2);
|
|
for (var i = 0; i < array2.length; i++) {
|
|
assertEq('Element ' + i, i, array[i]);
|
|
}
|
|
array.set(array2, 5);
|
|
for (var i = 0; i < array2.length; i++) {
|
|
assertEq('Element ' + i, i, array[5 + i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function negativeTestSetFromTypedArray(type, name) {
|
|
running('negativeTest ' + name + ' SetFromTypedArray');
|
|
try {
|
|
var array = new type(5);
|
|
var array2 = new type(6);
|
|
for (var i = 0; i < 5; i++) {
|
|
assertEq('Element ' + i, 0, array[i]);
|
|
}
|
|
for (var i = 0; i < array2.length; i++) {
|
|
array2[i] = i;
|
|
}
|
|
try {
|
|
array.set(array2);
|
|
fail('Expected exception from array.set(array2)');
|
|
return;
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
array2.set(array, 2);
|
|
fail('Expected exception from array2.set(array, 2)');
|
|
return;
|
|
} catch (e) {
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testSetFromArray(type, name) {
|
|
running('test ' + name + ' SetFromArray');
|
|
try {
|
|
var array = new type(10);
|
|
var array2 = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
|
|
for (var i = 0; i < 10; i++) {
|
|
assertEq('Element ' + i, 0, array[i]);
|
|
}
|
|
array.set(array2, 0);
|
|
for (var i = 0; i < array2.length; i++) {
|
|
assertEq('Element ' + i, 10 - i, array[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function negativeTestSetFromArray(type, name) {
|
|
running('negativeTest ' + name + ' SetFromArray');
|
|
try {
|
|
var array = new type([2, 3]);
|
|
try {
|
|
array.set([4, 5], 1);
|
|
fail();
|
|
return;
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
array.set([4, 5, 6]);
|
|
fail();
|
|
return;
|
|
} catch (e) {
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
var subarray;
|
|
function testSubarray(type, name) {
|
|
running('test ' + name + ' Subarray');
|
|
try {
|
|
var array = new type([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
var subarray = array.subarray(0, 5);
|
|
assertEq('subarray.length', 5, subarray.length);
|
|
for (var i = 0; i < 5; i++) {
|
|
assertEq('Element ' + i, i, subarray[i]);
|
|
}
|
|
subarray = array.subarray(4, 10);
|
|
assertEq('subarray.length', 6, subarray.length);
|
|
for (var i = 0; i < 6; i++) {
|
|
assertEq('Element ' + i, 4 + i, subarray[i]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testSubarrayOffsetAndLengthClamping(type, name) {
|
|
running('test ' + name + ' Subarray offset and length clamping');
|
|
try {
|
|
var array = new type([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
var subarray1 = array.subarray(0, 5);
|
|
var subarray2 = subarray1.subarray(-2, 10);
|
|
assertEq('subarray2.length', 2, subarray2.length);
|
|
assertEq('Element ' + 0, 3, subarray2[0]);
|
|
assertEq('Element ' + 1, 4, subarray2[1]);
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function negativeTestSubarray(type, name) {
|
|
running('negativeTest ' + name + ' Subarray');
|
|
try {
|
|
var array = new type([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
subarray = array.subarray(5, 11);
|
|
if (subarray.length != 5) {
|
|
fail();
|
|
return;
|
|
}
|
|
subarray = array.subarray(10, 10);
|
|
if (subarray.length != 0) {
|
|
fail();
|
|
return;
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testSetBoundaryConditions(type, name, testValues, expectedValues) {
|
|
running('test ' + name + ' SetBoundaryConditions');
|
|
try {
|
|
var array = new type(1);
|
|
assertEq('Array length', 1, array.length);
|
|
for (var ii = 0; ii < testValues.length; ++ii) {
|
|
for (var jj = 0; jj < 10; ++jj) {
|
|
array[0] = testValues[ii];
|
|
assertEq('Element 0', expectedValues[ii], array[0]);
|
|
}
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructionBoundaryConditions(type, name, testValues, expectedValues) {
|
|
running('test ' + name + ' ConstructionBoundaryConditions');
|
|
try {
|
|
var array = new type(testValues);
|
|
assertEq('Array length', testValues.length, array.length);
|
|
for (var ii = 0; ii < testValues.length; ++ii) {
|
|
assertEq('Element ' + ii, expectedValues[ii], array[ii]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
function testConstructionWithNullBuffer(type, name) {
|
|
var array;
|
|
try {
|
|
array = new type(null);
|
|
testPassed("Construction of " + name + " with null buffer shouldn't throw exception");
|
|
} catch (e) {
|
|
testPassed("Construction of " + name + " with null buffer threw exception");
|
|
}
|
|
try {
|
|
array = new type(null, 0);
|
|
testPassed("Construction of " + name + " with (null buffer, 0) shouldn't throw exception");
|
|
} catch (e) {
|
|
testFailed("Construction of " + name + " with (null buffer, 0) threw exception");
|
|
}
|
|
try {
|
|
array = new type(null, 0, 0);
|
|
testPassed("Construction of " + name + " with (null buffer, 0, 0) shouldn't throw exception");
|
|
} catch (e) {
|
|
testFailed("Construction of " + name + " with (null buffer, 0, 0) threw exception");
|
|
}
|
|
}
|
|
|
|
function testConstructionWithExceptionThrowingObject(type, name) {
|
|
var o = {};
|
|
Object.defineProperty(o, "length", { get: function() { throw "bail;" }});
|
|
try {
|
|
var array = new type(o);
|
|
} catch (e) {
|
|
}
|
|
testPassed("Construction of " + name + " with exception-throwing array-like object didn't crash unexpectedly");
|
|
}
|
|
|
|
function shouldThrowIndexSizeErr(func, text) {
|
|
var errorText = text + " should throw an exception";
|
|
try {
|
|
func();
|
|
testFailed(errorText);
|
|
} catch (e) {
|
|
testPassed(text + " threw an exception");
|
|
}
|
|
}
|
|
|
|
function shouldThrowTypeError(func, text) {
|
|
var ok = false;
|
|
try {
|
|
func();
|
|
} catch (e) {
|
|
if (e instanceof TypeError) {
|
|
ok = true;
|
|
}
|
|
}
|
|
if (ok) {
|
|
testPassed(text + " threw TypeError");
|
|
} else {
|
|
testFailed(text + " should throw TypeError");
|
|
}
|
|
}
|
|
|
|
function testConstructionWithOutOfRangeValues(type, name) {
|
|
shouldThrowIndexSizeErr(function() {
|
|
var buffer = new ArrayBuffer(4);
|
|
var array = new type(buffer, 4, 0x3FFFFFFF);
|
|
}, "Construction of " + name + " with out-of-range number of elements");
|
|
shouldThrowIndexSizeErr(function() {
|
|
var buffer = new ArrayBuffer(4);
|
|
var array = new type(buffer, 8);
|
|
}, "Construction of " + name + " with out-of-range offset");
|
|
}
|
|
|
|
function testConstructionWithNegativeOutOfRangeValues(type, name) {
|
|
try {
|
|
var buffer = new ArrayBuffer(-1);
|
|
testFailed("Construction of ArrayBuffer with negative size should throw exception");
|
|
} catch (e) {
|
|
testPassed("Construction of ArrayBuffer with negative size threw exception");
|
|
}
|
|
try {
|
|
var array = new type(-1);
|
|
testFailed("Construction of " + name + " with negative size should throw exception");
|
|
} catch (e) {
|
|
testPassed("Construction of " + name + " with negative size threw exception");
|
|
}
|
|
shouldThrowIndexSizeErr(function() {
|
|
var buffer = new ArrayBuffer(4);
|
|
var array = new type(buffer, 4, -2147483648);
|
|
}, "Construction of " + name + " with negative out-of-range values");
|
|
}
|
|
|
|
function testConstructionWithUnalignedOffset(type, name, elementSizeInBytes) {
|
|
if (elementSizeInBytes > 1) {
|
|
shouldThrowIndexSizeErr(function() {
|
|
var buffer = new ArrayBuffer(32);
|
|
var array = new type(buffer, 1, elementSizeInBytes);
|
|
}, "Construction of " + name + " with unaligned offset");
|
|
}
|
|
}
|
|
|
|
function testConstructionWithUnalignedLength(type, name, elementSizeInBytes) {
|
|
if (elementSizeInBytes > 1) {
|
|
shouldThrowIndexSizeErr(function() {
|
|
var buffer = new ArrayBuffer(elementSizeInBytes + 1);
|
|
var array = new type(buffer, 0);
|
|
}, "Construction of " + name + " with unaligned length");
|
|
}
|
|
}
|
|
|
|
function testConstructionOfHugeArray(type, name, sz) {
|
|
if (sz == 1)
|
|
return;
|
|
try {
|
|
// Construction of huge arrays must fail because byteLength is
|
|
// an unsigned long
|
|
array = new type(3000000000);
|
|
testFailed("Construction of huge " + name + " should throw exception");
|
|
} catch (e) {
|
|
testPassed("Construction of huge " + name + " threw exception");
|
|
}
|
|
}
|
|
|
|
function testConstructionWithBothArrayBufferAndLength(type, name, elementSizeInBytes) {
|
|
var bufByteLength = 1000 * elementSizeInBytes;
|
|
var buf = new ArrayBuffer(bufByteLength);
|
|
var array1 = new type(buf);
|
|
var array2 = new type(bufByteLength / elementSizeInBytes);
|
|
if (array1.length == array2.length) {
|
|
testPassed("Array lengths matched with explicit and implicit creation of ArrayBuffer");
|
|
} else {
|
|
testFailed("Array lengths DID NOT MATCH with explicit and implicit creation of ArrayBuffer");
|
|
}
|
|
}
|
|
|
|
function testConstructionWithSubPortionOfArrayBuffer(type, name, elementSizeInBytes) {
|
|
if (elementSizeInBytes > 1) {
|
|
// Test construction with a valid sub-portion of an array buffer
|
|
// (whose size is not an integral multiple of the element size).
|
|
var size = 4 * elementSizeInBytes + (elementSizeInBytes / 2);
|
|
var buf = new ArrayBuffer(size);
|
|
try {
|
|
var array = new type(buf, 0, 2);
|
|
testPassed("new " + name + "(new ArrayBuffer(" + size + "), 0, 2) succeeded");
|
|
} catch (e) {
|
|
testFailed("new " + name + "(new ArrayBuffer(" + size + "), 0, 2) failed: " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
// These need to be global for shouldBe to see them
|
|
var array;
|
|
var typeSize;
|
|
|
|
function testSubarrayWithOutOfRangeValues(type, name, sz) {
|
|
debug("Testing subarray of " + name);
|
|
try {
|
|
var buffer = new ArrayBuffer(32);
|
|
array = new type(buffer);
|
|
typeSize = sz;
|
|
shouldBe("array.length", "32 / typeSize");
|
|
try {
|
|
shouldBe("array.subarray(4, 0x3FFFFFFF).length", "(32 / typeSize) - 4");
|
|
shouldBe("array.subarray(4, -2147483648).length", "0");
|
|
// Test subarray() against overflows.
|
|
array = array.subarray(2);
|
|
if (sz > 1) {
|
|
// Full byte offset is +1 larger than the maximum unsigned long int.
|
|
// Make sure subarray() still handles it correctly. Otherwise overflow would happen and
|
|
// offset would be 0, and array.length array.length would incorrectly be 1.
|
|
var start = 4294967296 / sz - 2;
|
|
array = array.subarray(start, start + 1);
|
|
shouldBe("array.length", "0");
|
|
}
|
|
} catch (e) {
|
|
testFailed("Subarray of " + name + " threw exception");
|
|
}
|
|
} catch (e) {
|
|
testFailed("Exception: " + e);
|
|
}
|
|
}
|
|
|
|
function testSubarrayWithDefaultValues(type, name, sz) {
|
|
debug("Testing subarray with default inputs of " + name);
|
|
try {
|
|
var buffer = new ArrayBuffer(32);
|
|
array = new type(buffer);
|
|
typeSize = sz;
|
|
shouldBe("array.length", "32 / typeSize");
|
|
try {
|
|
shouldBe("array.subarray(0).length", "(32 / typeSize)");
|
|
shouldBe("array.subarray(2).length", "(32 / typeSize) - 2");
|
|
shouldBe("array.subarray(-2).length", "2");
|
|
shouldBe("array.subarray(-2147483648).length", "(32 / typeSize)");
|
|
} catch (e) {
|
|
testFailed("Subarray of " + name + " threw exception");
|
|
}
|
|
} catch (e) {
|
|
testFailed("Exception: " + e);
|
|
}
|
|
}
|
|
|
|
function setWithInvalidOffset(type, name, length,
|
|
sourceType, sourceName, sourceLength,
|
|
offset, offsetDescription) {
|
|
var webglArray = new type(length);
|
|
var sourceArray = new sourceType(sourceLength);
|
|
for (var i = 0; i < sourceLength; i++)
|
|
sourceArray[i] = 42 + i;
|
|
try {
|
|
webglArray.set(sourceArray, offset);
|
|
testFailed("Setting " + name + " from " + sourceName + " with " +
|
|
offsetDescription + " offset was not caught");
|
|
} catch (e) {
|
|
testPassed("Setting " + name + " from " + sourceName + " with " +
|
|
offsetDescription + " offset was caught");
|
|
}
|
|
}
|
|
|
|
function setWithValidOffset(type, name, length,
|
|
sourceType, sourceName, sourceLength,
|
|
offset, offsetDescription) {
|
|
running("Setting " + name + " from " + sourceName + " with " +
|
|
offsetDescription + " offset");
|
|
var webglArray = new type(length);
|
|
var sourceArray = new sourceType(sourceLength);
|
|
for (var i = 0; i < sourceLength; i++)
|
|
sourceArray[i] = 42 + i;
|
|
try {
|
|
webglArray.set(sourceArray, offset);
|
|
offset = Math.floor(offset);
|
|
for (var i = 0; i < sourceLength; i++) {
|
|
assertEq("Element " + i + offset, sourceArray[i], webglArray[i + offset]);
|
|
}
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
|
|
function testSettingFromArrayWithOutOfRangeOffset(type, name) {
|
|
setWithInvalidOffset(type, name, 32, Array, "array", 16,
|
|
0x7FFFFFF8, "out-of-range");
|
|
}
|
|
|
|
function testSettingFromTypedArrayWithOutOfRangeOffset(type, name) {
|
|
setWithInvalidOffset(type, name, 32, type, name, 16,
|
|
0x7FFFFFF8, "out-of-range");
|
|
}
|
|
|
|
function testSettingFromArrayWithNegativeOffset(type, name) {
|
|
setWithInvalidOffset(type, name, 32, Array, "array", 16,
|
|
-1, "negative");
|
|
}
|
|
|
|
function testSettingFromTypedArrayWithNegativeOffset(type, name) {
|
|
setWithInvalidOffset(type, name, 32, type, name, 16,
|
|
-1, "negative");
|
|
}
|
|
|
|
function testSettingFromArrayWithMinusZeroOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, Array, "array", 16,
|
|
-0, "-0");
|
|
}
|
|
|
|
function testSettingFromTypedArrayWithMinusZeroOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, type, name, 16,
|
|
-0, "-0");
|
|
}
|
|
|
|
function testSettingFromArrayWithBoundaryOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, Array, "array", 16,
|
|
16, "boundary");
|
|
}
|
|
|
|
function testSettingFromTypedArrayWithBoundaryOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, type, name, 16,
|
|
16, "boundary");
|
|
}
|
|
|
|
function testSettingFromArrayWithNonIntegerOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, Array, "array", 16,
|
|
16.999, "non-integer");
|
|
}
|
|
|
|
function testSettingFromTypedArrayWithNonIntegerOffset(type, name) {
|
|
setWithValidOffset(type, name, 32, type, name, 16,
|
|
16.999, "non-integer");
|
|
}
|
|
|
|
function testSettingFromFakeArrayWithOutOfRangeLength(type, name) {
|
|
var webglArray = new type(32);
|
|
var array = {};
|
|
array.length = 0x80000000;
|
|
try {
|
|
webglArray.set(array, 8);
|
|
testFailed("Setting " + name + " from fake array with invalid length was not caught");
|
|
} catch (e) {
|
|
testPassed("Setting " + name + " from fake array with invalid length was caught");
|
|
}
|
|
}
|
|
|
|
|
|
function negativeTestGetAndSetMethods(type, name) {
|
|
array = new type([2, 3]);
|
|
shouldBeUndefined("array.get");
|
|
var exceptionThrown = false;
|
|
// We deliberately check for an exception here rather than using
|
|
// shouldThrow here because the precise contents of the syntax
|
|
// error are not specified.
|
|
try {
|
|
webGLArray.set(0, 1);
|
|
} catch (e) {
|
|
exceptionThrown = true;
|
|
}
|
|
var output = "array.set(0, 1) ";
|
|
if (exceptionThrown) {
|
|
testPassed(output + "threw exception.");
|
|
} else {
|
|
testFailed(output + "did not throw exception.");
|
|
}
|
|
}
|
|
|
|
function testNaNConversion(type, name) {
|
|
running('test storing NaN in ' + name);
|
|
|
|
var array = new type([1, 1]);
|
|
var results = [];
|
|
|
|
// The code block in each of the case statements below is identical, but some
|
|
// JavaScript engines need separate copies in order to exercise all of
|
|
// their optimized code paths.
|
|
try {
|
|
switch (type) {
|
|
case Float32Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Float64Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Int8Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Int16Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Int32Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Uint8Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Uint8ClampedArray:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Uint16Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
case Uint32Array:
|
|
for (var i = 0; i < array.length; ++i) {
|
|
array[i] = NaN;
|
|
results[i] = array[i];
|
|
}
|
|
break;
|
|
default:
|
|
fail("Unhandled type");
|
|
break;
|
|
}
|
|
|
|
// Some types preserve NaN values; all other types convert NaN to zero.
|
|
if (type === Float32Array || type === Float64Array) {
|
|
assert('initial NaN preserved', isNaN(new type([NaN])[0]));
|
|
for (var i = 0; i < array.length; ++i)
|
|
assert('NaN preserved via setter', isNaN(results[i]));
|
|
} else {
|
|
assertEq('initial NaN converted to zero', 0, new type([NaN])[0]);
|
|
for (var i = 0; i < array.length; ++i)
|
|
assertEq('NaN converted to zero by setter', 0, results[i]);
|
|
}
|
|
|
|
pass();
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Test driver
|
|
//
|
|
|
|
function runTests() {
|
|
allPassed = true;
|
|
|
|
testSlice();
|
|
testInheritanceHierarchy();
|
|
|
|
for (var i = 0; i < testCases.length; i++) {
|
|
var testCase = testCases[i];
|
|
running(testCase.name);
|
|
if (!(testCase.name in window)) {
|
|
fail("does not exist");
|
|
continue;
|
|
}
|
|
var type = window[testCase.name];
|
|
var name = testCase.name;
|
|
if (testCase.unsigned) {
|
|
testSetAndGet10To1(type, name);
|
|
testConstructWithArrayOfUnsignedValues(type, name);
|
|
testConstructWithTypedArrayOfUnsignedValues(type, name);
|
|
} else {
|
|
testSetAndGetPos10ToNeg10(type, name);
|
|
testConstructWithArrayOfSignedValues(type, name);
|
|
testConstructWithTypedArrayOfSignedValues(type, name);
|
|
}
|
|
if (testCase.integral) {
|
|
testIntegralArrayTruncationBehavior(type, name, testCase.unsigned);
|
|
}
|
|
testGetWithOutOfRangeIndices(type, name);
|
|
testOffsetsAndSizes(type, name, testCase.elementSizeInBytes);
|
|
testSetFromTypedArray(type, name);
|
|
negativeTestSetFromTypedArray(type, name);
|
|
testSetFromArray(type, name);
|
|
negativeTestSetFromArray(type, name);
|
|
testSubarray(type, name);
|
|
testSubarrayOffsetAndLengthClamping(type, name);
|
|
negativeTestSubarray(type, name);
|
|
testSetBoundaryConditions(type,
|
|
name,
|
|
testCase.testValues,
|
|
testCase.expectedValues);
|
|
testConstructionBoundaryConditions(type,
|
|
name,
|
|
testCase.testValues,
|
|
testCase.expectedValues);
|
|
testConstructionWithNullBuffer(type, name);
|
|
testConstructionWithExceptionThrowingObject(type, name);
|
|
testConstructionWithOutOfRangeValues(type, name);
|
|
testConstructionWithNegativeOutOfRangeValues(type, name);
|
|
testConstructionWithUnalignedOffset(type, name, testCase.elementSizeInBytes);
|
|
testConstructionWithUnalignedLength(type, name, testCase.elementSizeInBytes);
|
|
testConstructionOfHugeArray(type, name, testCase.elementSizeInBytes);
|
|
testConstructionWithBothArrayBufferAndLength(type, name, testCase.elementSizeInBytes);
|
|
testConstructionWithSubPortionOfArrayBuffer(type, name, testCase.elementSizeInBytes);
|
|
testSubarrayWithOutOfRangeValues(type, name, testCase.elementSizeInBytes);
|
|
testSubarrayWithDefaultValues(type, name, testCase.elementSizeInBytes);
|
|
testSettingFromArrayWithOutOfRangeOffset(type, name);
|
|
testSettingFromTypedArrayWithOutOfRangeOffset(type, name);
|
|
testSettingFromArrayWithNegativeOffset(type, name);
|
|
testSettingFromTypedArrayWithNegativeOffset(type, name);
|
|
testSettingFromArrayWithMinusZeroOffset(type, name);
|
|
testSettingFromTypedArrayWithMinusZeroOffset(type, name);
|
|
testSettingFromArrayWithBoundaryOffset(type, name);
|
|
testSettingFromTypedArrayWithBoundaryOffset(type, name);
|
|
testSettingFromArrayWithNonIntegerOffset(type, name);
|
|
testSettingFromTypedArrayWithNonIntegerOffset(type, name);
|
|
testSettingFromFakeArrayWithOutOfRangeLength(type, name);
|
|
negativeTestGetAndSetMethods(type, name);
|
|
testNaNConversion(type, name);
|
|
}
|
|
|
|
printSummary();
|
|
}
|
|
|
|
runTests();
|
|
</script>
|
|
</body>
|
|
</html>
|