diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/conformance/typedarrays/typed-arrays-in-workers.html')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/conformance/typedarrays/typed-arrays-in-workers.html | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/typedarrays/typed-arrays-in-workers.html b/dom/canvas/test/webgl-conf/checkout/conformance/typedarrays/typed-arrays-in-workers.html new file mode 100644 index 0000000000..69eb057589 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/typedarrays/typed-arrays-in-workers.html @@ -0,0 +1,257 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/test-eval.js"></script> +<script src="../../js/tests/typed-array-test-cases.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> + +<script> +"use strict"; + +var testQueue = []; +var transferSupported = true; + +function nextTest() { + if (testQueue[0].subTests.length > 0) { + testQueue[0].subTests.shift(); + } + + while (testQueue.length > 0 && testQueue[0].subTests.length == 0) { + testQueue.shift(); + } + + if (testQueue.length == 0) { + finishTest(); + return; + } + + testQueue[0].subTests[0].runner(); +} + +function handleMessage(event) { + if (testQueue.length == 0) + return; + + if (testQueue[0].subTests.length == 0) + return; + + testQueue[0].subTests[0].checker(event); + nextTest(); +} + +function setupTest(testCase, runner, checker) { + testCase.subTests.push({ runner: runner.bind(null, testCase), checker: checker.bind(null, testCase) }); +} + +function arrayToString(arr) { + var result = "[ "; + for (var ii = 0; ii < arr.length; ++ii) { + if (ii > 0) + result += ", "; + result += arr[ii]; + } + return result + " ]"; +} + +function constructTypedArray(type, data) { + if (type == 'Int8Array') { + return new Int8Array(data); + } else if (type == 'Uint8Array') { + return new Uint8Array(data); + } else if (type == 'Uint8ClampedArray') { + return new Uint8ClampedArray(data); + } else if (type == 'Int16Array') { + return new Int16Array(data); + } else if (type == 'Uint16Array') { + return new Uint16Array(data); + } else if (type == 'Int32Array') { + return new Int32Array(data); + } else if (type == 'Uint32Array') { + return new Uint32Array(data); + } else if (type == 'Float32Array') { + return new Float32Array(data); + } else if (type == 'Float64Array') { + return new Float64Array(data); + } +} + +// Test runner / checker pairs +function runTestWithData(command, testCase) { + worker.postMessage({command: command, type: testCase.name, subType: testCase.subType, elementSizeInBytes: testCase.elementSizeInBytes, data: testCase.testValues}); +} + +function checkArraysEqual(testKind, testCase, event) { + var array = event.data; + var testName = testKind + " " + testCase.name + " from worker to main thread"; + if (areArraysEqual(array, testCase.expectedValues)) { + testPassed(testName); + } else { + testFailed(testName + ": expected " + arrayToString(testCase.expectedValues) + ", received " + arrayToString(array)); + } +} + +function checkBufferContentsEqual(testKind, testCase, event) { + var array = constructTypedArray(testCase.name, event.data); + var testName = testKind + " containing " + testCase.name + " values from worker to main thread"; + if (areArraysEqual(array, testCase.expectedValues)) { + testPassed(testName); + } else { + testFailed(testName + ": expected " + arrayToString(testCase.expectedValues) + ", received " + arrayToString(array)); + } +} + +function checkDataViewContents(testKind, testCase, event) { + var dataView = event.data; + var testName = testKind + " " + testCase.name + " containing " + testCase.subType + " from worker to main thread"; + var byteOffset = 0; + var allPassed = true; + for (var ii = 0; ii < testCase.expectedValues.length; ++ii) { + var expected = testCase.expectedValues[ii]; + var received = dataView['get' + testCase.subType](byteOffset); + if (received != expected) { + allPassed = false; + testFailed(testName + ": at byte offset " + byteOffset + ": expected " + expected + ", received " + received); + } + byteOffset += testCase.elementSizeInBytes; + } + if (allPassed) { + testPassed(testName); + } +} + +// Missing test: copy or transfer ArrayBuffer, wrap in DataView on this end, verify contents. + +function noop() { +} + +function checkArraysEqualAndPingPong(testKind, transfer, testCase, event) { + checkArraysEqual(testKind, testCase, event); + var transferables = []; + if (transfer) { + transferables.push(event.data.buffer); + } + try { + worker.postMessage({ command: 'pong', data: event.data, transferables: transferables }, transferables); + } catch (e) { + testFailed("unexpected exception: " + e); + } +} + +function checkBufferContentsEqualAndPingPong(testKind, transfer, testCase, event) { + checkBufferContentsEqual(testKind, testCase, event); + var transferables = []; + if (transfer) { + transferables.push(event.data); + } + try { + worker.postMessage({ command: 'pong', data: event.data, transferables: transferables }, transferables); + } catch (e) { + testFailed("unexpected exception: " + e); + } +} + +function checkDataViewContentsAndPingPong(testKind, transfer, testCase, event) { + checkDataViewContents(testKind, testCase, event); + var transferables = []; + if (transfer) { + transferables.push(event.data.buffer); + } + try { + worker.postMessage({ command: 'pong', data: event.data, transferables: transferables }, transferables); + } catch (e) { + testFailed("unexpected exception: " + e); + } +} + +description("Tests copying and transferring typed arrays and ArrayBuffers to and from workers"); + +// See whether workers are supported at all +if (window.Worker) { + // Start up the worker + var worker = new Worker('../../js/tests/typed-array-worker.js'); + worker.onmessage = handleMessage; + + // See whether transferables are supported + var buffer = new ArrayBuffer(16); + try { + worker.postMessage({ command: 'ignore', data: buffer }, [buffer]); + if (buffer.byteLength > 0) + transferSupported = false; + } catch (e) { + transferSupported = false; + } + + // Iterate down the tests, queueing them up + for (var ii = 0; ii < testCases.length; ++ii) { + var testCase = testCases[ii]; + testCase.subTests = []; + setupTest(testCase, runTestWithData.bind(null, 'copy'), checkArraysEqual.bind(null, 'copy')); + setupTest(testCase, runTestWithData.bind(null, 'copyBuffer'), checkBufferContentsEqual.bind(null, 'copy ArrayBuffer')); + setupTest(testCase, runTestWithData.bind(null, 'transfer'), checkArraysEqual.bind(null, 'transfer')); + setupTest(testCase, runTestWithData.bind(null, 'transferBuffer'), checkBufferContentsEqual.bind(null, 'transfer ArrayBuffer')); + + // These two must run back-to-back + setupTest(testCase, runTestWithData.bind(null, 'copy'), checkArraysEqualAndPingPong.bind(null, 'copy', false)); + setupTest(testCase, noop, checkArraysEqual.bind(null, 'ping-pong with copy')); + + // These two must run back-to-back + setupTest(testCase, runTestWithData.bind(null, 'copyBuffer'), checkBufferContentsEqualAndPingPong.bind(null, 'copy ArrayBuffer', false)); + setupTest(testCase, noop, checkBufferContentsEqual.bind(null, 'ping-pong with copy')); + + // These two must run back-to-back + setupTest(testCase, runTestWithData.bind(null, 'transfer'), checkArraysEqualAndPingPong.bind(null, 'transfer', true)); + setupTest(testCase, noop, checkArraysEqual.bind(null, 'ping-pong with transfer')); + + // These two must run back-to-back + setupTest(testCase, runTestWithData.bind(null, 'transferBuffer'), checkBufferContentsEqualAndPingPong.bind(null, 'transfer ArrayBuffer', false)); + setupTest(testCase, noop, checkBufferContentsEqual.bind(null, 'ping-pong with transfer')); + + testQueue.push(testCase); + + // Add just a couple of DataView tests; the behavior of that view type is thoroughly tested elsewhere + if (testCase.name == "Float32Array" || testCase.name == "Int32Array") { + var subTypeName = (testCase.name == "Float32Array" ? "Float32" : "Int32"); + var dataViewTestCase = { name: "DataView", + subType: subTypeName, + elementSizeInBytes: testCase.elementSizeInBytes, + testValues: testCase.testValues, + expectedValues: testCase.expectedValues, + subTests: [] }; + setupTest(dataViewTestCase, runTestWithData.bind(null, 'copy'), checkDataViewContents.bind(null, 'copy')); + setupTest(dataViewTestCase, runTestWithData.bind(null, 'transfer'), checkDataViewContents.bind(null, 'transfer')); + + // These two must run back-to-back + setupTest(dataViewTestCase, runTestWithData.bind(null, 'copy'), checkDataViewContentsAndPingPong.bind(null, 'copy', false)); + setupTest(dataViewTestCase, noop, checkDataViewContents.bind(null, 'ping-pong with copy')); + + // These two must run back-to-back + setupTest(dataViewTestCase, runTestWithData.bind(null, 'transfer'), checkDataViewContentsAndPingPong.bind(null, 'transfer', false)); + setupTest(dataViewTestCase, noop, checkDataViewContents.bind(null, 'ping-pong with transfer')); + + testQueue.push(dataViewTestCase); + } + } + + // Kick things off + testQueue[0].subTests[0].runner(); +} else { + debug("Workers not supported -- skipping test"); + finishTest(); +} + +var successfullyParsed = true; +</script> +</body> +</html> |