| <!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> |
