path: root/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fBufferCopyTests.js

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

});