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();
+        }
+    };
+
+});