diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js | 355 |
1 files changed, 355 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js new file mode 100644 index 0000000000..51186231a6 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js @@ -0,0 +1,355 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +'use strict'; +goog.provide('functional.gles3.es3fBufferCopyTests'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.delibs.debase.deString'); +goog.require('modules.shared.glsBufferTestUtil'); + +goog.scope(function() { + + var es3fBufferCopyTests = functional.gles3.es3fBufferCopyTests; + var glsBufferTestUtil = modules.shared.glsBufferTestUtil; + var tcuTestCase = framework.common.tcuTestCase; + var deMath = framework.delibs.debase.deMath; + var deString = framework.delibs.debase.deString; + var deRandom = framework.delibs.debase.deRandom; + + /** @type {WebGL2RenderingContext} */ var gl; + + /** + * @constructor + * @extends {glsBufferTestUtil.BufferCase} + * @param {string} name + * @param {string} desc + * @param {number} srcTarget + * @param {number} srcSize + * @param {number} srcHint + * @param {number} dstTarget + * @param {number} dstSize + * @param {number} dstHint + * @param {number} copySrcOffset + * @param {number} copyDstOffset + * @param {number} copySize + * @param {glsBufferTestUtil.VerifyType} verifyType + */ + es3fBufferCopyTests.BasicBufferCopyCase = function(name, desc, srcTarget, srcSize, srcHint, dstTarget, dstSize, dstHint, copySrcOffset, copyDstOffset, copySize, verifyType) { + glsBufferTestUtil.BufferCase.call(this, name, desc); + + this.m_srcTarget = srcTarget; + this.m_srcSize = srcSize; + this.m_srcHint = srcHint; + this.m_dstTarget = dstTarget; + this.m_dstSize = dstSize; + this.m_dstHint = dstHint; + this.m_copySrcOffset = copySrcOffset; + this.m_copyDstOffset = copyDstOffset; + this.m_copySize = copySize; + this.m_verifyType = verifyType; + + assertMsgOptions(deMath.deInBounds32(this.m_copySrcOffset, 0, this.m_srcSize) && deMath.deInRange32(this.m_copySrcOffset + this.m_copySize, this.m_copySrcOffset, this.m_srcSize), 'Copy parameters are out of buffer\'s range', false, true); + assertMsgOptions(deMath.deInBounds32(this.m_copyDstOffset, 0, this.m_dstSize) && deMath.deInRange32(this.m_copyDstOffset + this.m_copySize, this.m_copyDstOffset, this.m_dstSize), 'Copy parameters are out of buffer\'s range', false, true); + }; + + es3fBufferCopyTests.BasicBufferCopyCase.prototype = Object.create(glsBufferTestUtil.BufferCase.prototype); + es3fBufferCopyTests.BasicBufferCopyCase.prototype.constructor = es3fBufferCopyTests.BasicBufferCopyCase; + + /** + * @return {tcuTestCase.IterateResult} + */ + es3fBufferCopyTests.BasicBufferCopyCase.prototype.iterate = function() { + /** @type {glsBufferTestUtil.BufferVerifier} */ var verifier = new glsBufferTestUtil.BufferVerifier(this.m_verifyType); + var srcRef = new glsBufferTestUtil.ReferenceBuffer(); + var dstRef = new glsBufferTestUtil.ReferenceBuffer(); + var srcBuf = 0; + var dstBuf = 0; + var srcSeed = deMath.binaryOp(deString.deStringHash(this.fullName()), 0xabcd, deMath.BinaryOp.XOR); + var dstSeed = deMath.binaryOp(deString.deStringHash(this.fullName()), 0xef01, deMath.BinaryOp.XOR); + var isOk = true; + + srcRef.setSize(this.m_srcSize); + glsBufferTestUtil.fillWithRandomBytes(srcRef.getPtr(), this.m_srcSize, srcSeed); + + dstRef.setSize(this.m_dstSize); + glsBufferTestUtil.fillWithRandomBytes(dstRef.getPtr(), this.m_dstSize, dstSeed); + + // Create source buffer and fill with data. + srcBuf = this.genBuffer(); + gl.bindBuffer(this.m_srcTarget, srcBuf); + gl.bufferData(this.m_srcTarget, srcRef.getPtr(), this.m_srcHint); + + // Create destination buffer and fill with data. + dstBuf = this.genBuffer(); + gl.bindBuffer(this.m_dstTarget, dstBuf); + gl.bufferData(this.m_dstTarget, dstRef.getPtr(), this.m_dstHint); + + // Verify both buffers before executing copy. + isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, this.m_srcSize, this.m_srcTarget) && isOk; + isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, this.m_dstSize, this.m_dstTarget) && isOk; + + // Execute copy. + dstRef.getPtr().set(srcRef.getPtr().subarray(this.m_copySrcOffset, this.m_copySrcOffset + this.m_copySize), this.m_copyDstOffset); + + gl.bindBuffer(this.m_srcTarget, srcBuf); + gl.bindBuffer(this.m_dstTarget, dstBuf); + gl.copyBufferSubData(this.m_srcTarget, this.m_dstTarget, this.m_copySrcOffset, this.m_copyDstOffset, this.m_copySize); + + // Verify both buffers after copy. + isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, this.m_srcSize, this.m_srcTarget) && isOk; + isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, this.m_dstSize, this.m_dstTarget) && isOk; + + if (isOk) + testPassed(''); + else + testFailed('Buffer verification failed'); + + return tcuTestCase.IterateResult.STOP; + }; + + // Case B: same buffer, take range as parameter + + /** + * @constructor + * @extends {glsBufferTestUtil.BufferCase} + * @param {string} name + * @param {string} desc + * @param {number} srcTarget + * @param {number} dstTarget + * @param {number} hint + * @param {glsBufferTestUtil.VerifyType} verifyType + */ + es3fBufferCopyTests.SingleBufferCopyCase = function(name, desc, srcTarget, dstTarget, hint, verifyType) { + glsBufferTestUtil.BufferCase.call(this, name, desc); + this.m_srcTarget = srcTarget; + this.m_dstTarget = dstTarget; + this.m_hint = hint; + this.m_verifyType = verifyType; + }; + + es3fBufferCopyTests.SingleBufferCopyCase.prototype = Object.create(glsBufferTestUtil.BufferCase.prototype); + es3fBufferCopyTests.SingleBufferCopyCase.prototype.constructor = es3fBufferCopyTests.SingleBufferCopyCase; + + /** + * @return {tcuTestCase.IterateResult} + */ + es3fBufferCopyTests.SingleBufferCopyCase.prototype.iterate = function() { + var size = 1000; + /** @type {glsBufferTestUtil.BufferVerifier} */ var verifier = new glsBufferTestUtil.BufferVerifier(this.m_verifyType); + var ref = new glsBufferTestUtil.ReferenceBuffer(); + var baseSeed = deString.deStringHash(this.fullName()); + var isOk = true; + + ref.setSize(size); + + // Create buffer. + var buf = this.genBuffer(); + gl.bindBuffer(this.m_srcTarget, buf); + + /** @type {Array<{srcOffset: number, dstOffset: number, copySize: number}>} */ + var copyRanges = [{ + srcOffset: 57, dstOffset: 701, copySize: 101 // Non-adjecent, from low to high. + },{ + srcOffset: 640, dstOffset: 101, copySize: 101 // Non-adjecent, from high to low. + },{ + srcOffset: 0, dstOffset: 500, copySize: 500 // Lower half to upper half. + },{ + srcOffset: 500, dstOffset: 0, copySize: 500 // Upper half to lower half. + }]; + + for (var ndx = 0; ndx < copyRanges.length && isOk; ndx++) { + var srcOffset = copyRanges[ndx].srcOffset; + var dstOffset = copyRanges[ndx].dstOffset; + var copySize = copyRanges[ndx].copySize; + + glsBufferTestUtil.fillWithRandomBytes(ref.getPtr(), size, deMath.binaryOp(baseSeed, deMath.deMathHash(ndx), deMath.BinaryOp.XOR)); + + // Fill with data. + gl.bindBuffer(this.m_srcTarget, buf); + gl.bufferData(this.m_srcTarget, ref.getPtr(), this.m_hint); + + // Execute copy. + ref.getPtr().set(ref.getPtr().subarray(srcOffset, srcOffset + copySize), dstOffset); + + gl.bindBuffer(this.m_dstTarget, buf); + gl.copyBufferSubData(this.m_srcTarget, this.m_dstTarget, srcOffset, dstOffset, copySize); + + // Verify buffer after copy. + isOk = verifier.verify(buf, ref.getPtr(), 0, size, this.m_dstTarget) && isOk; + } + + if (isOk) + testPassed(''); + else + testFailed('Buffer verification failed'); + + return tcuTestCase.IterateResult.STOP; + }; + + /** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ + es3fBufferCopyTests.BufferCopyTests = function() { + tcuTestCase.DeqpTest.call(this, 'copy', 'Buffer copy tests'); + this.makeExecutable(); + }; + + es3fBufferCopyTests.BufferCopyTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fBufferCopyTests.BufferCopyTests.prototype.constructor = es3fBufferCopyTests.BufferCopyTests; + + es3fBufferCopyTests.BufferCopyTests.prototype.init = function() { + /** @type {glsBufferTestUtil.VerifyType} */ var verify; + + var bufferTargets = [ + gl.ARRAY_BUFFER, + gl.COPY_READ_BUFFER, + gl.COPY_WRITE_BUFFER, + gl.ELEMENT_ARRAY_BUFFER, + gl.PIXEL_PACK_BUFFER, + gl.PIXEL_UNPACK_BUFFER, + gl.TRANSFORM_FEEDBACK_BUFFER, + gl.UNIFORM_BUFFER + ]; + + // .basic + + var basicGroup = new tcuTestCase.DeqpTest('basic', 'Basic buffer copy cases'); + this.addChild(basicGroup); + + for (var srcTargetNdx = 0; srcTargetNdx < bufferTargets.length; srcTargetNdx++) { + for (var dstTargetNdx = 0; dstTargetNdx < bufferTargets.length; dstTargetNdx++) { + if (srcTargetNdx == dstTargetNdx) + continue; + + // In WebGL 2, a copy between an ELEMENT_ARRAY_BUFFER and other data buffer + // (not COPY_WRITE_BUFFER nor COPY_READ_BUFFER nor ELEMENT_ARRAY_BUFFER) + // cannot be made, so let's skip those cases. + if (bufferTargets[srcTargetNdx] == gl.ELEMENT_ARRAY_BUFFER || + bufferTargets[dstTargetNdx] == gl.ELEMENT_ARRAY_BUFFER) + continue; + + var srcTarget = bufferTargets[srcTargetNdx]; + var dstTarget = bufferTargets[dstTargetNdx]; + var size = 1017; + var hint = gl.STATIC_DRAW; + verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY; + var name = glsBufferTestUtil.getBufferTargetName(srcTarget) + '_' + glsBufferTestUtil.getBufferTargetName(dstTarget); + + basicGroup.addChild(new es3fBufferCopyTests.BasicBufferCopyCase(name, '', srcTarget, size, hint, dstTarget, size, hint, 0, 0, size, verify)); + } + } + + // .subrange + + var subrangeGroup = new tcuTestCase.DeqpTest('subrange', 'Buffer subrange copy tests'); + this.addChild(subrangeGroup); + + /** + * @type {Array<{name: string, srcSize: number, dstSize: number, srcOffset: number, dstOffset: number, copySize: number}>} + */ + var cases = [{ + name: 'middle', srcSize: 1000, dstSize: 1000, srcOffset: 250, dstOffset: 250, copySize: 500 + },{ + name: 'small_to_large', srcSize: 100, dstSize: 1000, srcOffset: 0, dstOffset: 409, copySize: 100 + },{ + name: 'large_to_small', srcSize: 1000, dstSize: 100, srcOffset: 409, dstOffset: 0, copySize: 100 + },{ + name: 'low_to_high_1', srcSize: 1000, dstSize: 1000, srcOffset: 0, dstOffset: 500, copySize: 500 + },{ + name: 'low_to_high_2', srcSize: 997, dstSize: 1027, srcOffset: 0, dstOffset: 701, copySize: 111 + },{ + name: 'high_to_low_1', srcSize: 1000, dstSize: 1000, srcOffset: 500, dstOffset: 0, copySize: 500 + },{ + name: 'high_to_low_2', srcSize: 1027, dstSize: 997, srcOffset: 701, dstOffset: 17, copySize: 111 + }]; + + for (var ndx = 0; ndx < cases.length; ndx++) { + var srcTarget = gl.COPY_READ_BUFFER; + var dstTarget = gl.COPY_WRITE_BUFFER; + var hint = gl.STATIC_DRAW; + verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY; + + subrangeGroup.addChild( + new es3fBufferCopyTests.BasicBufferCopyCase( + cases[ndx].name, '', + srcTarget, cases[ndx].srcSize, hint, + dstTarget, cases[ndx].dstSize, hint, + cases[ndx].srcOffset, cases[ndx].dstOffset, cases[ndx].copySize, + verify + ) + ); + } + + // .single_buffer + + var singleBufGroup = new tcuTestCase.DeqpTest('single_buffer', 'Copies within single buffer'); + this.addChild(singleBufGroup); + + for (var srcTargetNdx = 0; srcTargetNdx < bufferTargets.length; srcTargetNdx++) { + for (var dstTargetNdx = 0; dstTargetNdx < bufferTargets.length; dstTargetNdx++) { + if (srcTargetNdx == dstTargetNdx) + continue; + + // In WebGL 2, we can't rebind an ELEMENT_ARRAY_BUFFER or TRANSFORM_FEEDBACK_BUFFER as a + // different type of buffer, so we skip those cases. + if (bufferTargets[srcTargetNdx] == gl.ELEMENT_ARRAY_BUFFER || bufferTargets[srcTargetNdx] == gl.TRANSFORM_FEEDBACK_BUFFER || + bufferTargets[dstTargetNdx] == gl.ELEMENT_ARRAY_BUFFER || bufferTargets[dstTargetNdx] == gl.TRANSFORM_FEEDBACK_BUFFER) + continue; + + var srcTarget = bufferTargets[srcTargetNdx]; + var dstTarget = bufferTargets[dstTargetNdx]; + var hint = gl.STATIC_DRAW; + verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY; + var name = glsBufferTestUtil.getBufferTargetName(srcTarget) + '_' + glsBufferTestUtil.getBufferTargetName(dstTarget); + + singleBufGroup.addChild(new es3fBufferCopyTests.SingleBufferCopyCase(name, '', srcTarget, dstTarget, hint, verify)); + } + } + }; + + /** + * Create and execute the test cases + * @param {WebGL2RenderingContext} context + */ + es3fBufferCopyTests.run = function(context) { + gl = context; + //Set up Test Root parameters + var state = tcuTestCase.runner; + + state.setRoot(new es3fBufferCopyTests.BufferCopyTests()); + + //Set up name and description of this test series. + setCurrentTestName(state.testCases.fullName()); + description(state.testCases.getDescription()); + + try { + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to run tests', false); + tcuTestCase.runner.terminate(); + } + }; + +}); |