/*-------------------------------------------------------------------------
 * 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.es3fFboColorbufferTests');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTexture');
goog.require('framework.opengl.gluTextureUtil');
goog.require('functional.gles3.es3fFboTestCase');
goog.require('functional.gles3.es3fFboTestUtil');
goog.require('framework.common.tcuRGBA');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuTextureUtil');
goog.require('framework.referencerenderer.rrUtil');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.opengl.gluShaderUtil');

goog.scope(function() {
var es3fFboColorbufferTests = functional.gles3.es3fFboColorbufferTests;
var es3fFboTestCase = functional.gles3.es3fFboTestCase;
var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var tcuTexture = framework.common.tcuTexture;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var tcuRGBA = framework.common.tcuRGBA;
var deRandom = framework.delibs.debase.deRandom;
var tcuImageCompare = framework.common.tcuImageCompare;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var rrUtil = framework.referencerenderer.rrUtil;
var deMath = framework.delibs.debase.deMath;
var gluShaderUtil = framework.opengl.gluShaderUtil;

/** @type {WebGL2RenderingContext} */ var gl;

/** @const*/ var MIN_THRESHOLD = new tcuRGBA.RGBA([12, 12, 12, 12]);

let canvasWH = 256;
let texPotSize = [128, 128, 5];
let texNpotSizeA = [129, 117];
let texNpotSizeB = [99, 128];
if (tcuTestCase.isQuickMode()) {
    canvasWH = 32;
    texPotSize = [16, 16, 5];
    texNpotSizeA = [12, 11];
    texNpotSizeB = [9, 16];
}
const texW = texPotSize[0];
const texH = texPotSize[1];

var setParentClass = function(child, parent) {
    child.prototype = Object.create(parent.prototype);
    child.prototype.constructor = child;
};

/**
 * @param {deRandom.Random} rnd
 * @param {Array<number>} minVal
 * @param {Array<number>} maxVal
 * @return {Array<number>}
 */
es3fFboColorbufferTests.randomVector = function(rnd, minVal, maxVal) {
    var res = [];
    for (var ndx = 0; ndx < minVal.length; ndx++)
        res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]);
    return res;
};

/**
 * @param {deRandom.Random} rnd
 * @return {Array<number>}
 */
es3fFboColorbufferTests.generateRandomColor = function(rnd) {
    var retVal = [];

    for (var i = 0; i < 3; ++i)
        retVal[i] = rnd.getFloat();
    retVal[3] = 1;

    return retVal;
};

/**
 * @constructor
 * @extends {es3fFboTestCase.FboTestCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} format
 */
es3fFboColorbufferTests.FboColorbufferCase = function(name, desc, format) {
    es3fFboTestCase.FboTestCase.call(this, name, desc);
    this.m_format = format;
};

setParentClass(es3fFboColorbufferTests.FboColorbufferCase, es3fFboTestCase.FboTestCase);

/**
 * @param {tcuSurface.Surface} reference
 * @param {tcuSurface.Surface} result
 * @return {boolean}
 */
es3fFboColorbufferTests.FboColorbufferCase.prototype.compare = function(reference, result) {
        /** @type {tcuRGBA.RGBA} */ var threshold = tcuRGBA.max(es3fFboTestUtil.getFormatThreshold(this.m_format), MIN_THRESHOLD);

        bufferedLogToConsole('Comparing images, threshold: ' + threshold);

        return tcuImageCompare.bilinearCompare('Result', 'Image comparison result', reference.getAccess(), result.getAccess(), threshold);
    };

/**
 * Deinit. Clear some GL state variables
 */
es3fFboColorbufferTests.FboColorbufferCase.prototype.deinit = function() {
        // Texture state
        {
            // Only TEXTURE0 and TEXTURE1 are used in this test
            var numTexUnits = 2;

            for (var ndx = 0; ndx < numTexUnits; ndx++) {
                gl.activeTexture(gl.TEXTURE0 + ndx);

                // Reset 2D texture
                gl.bindTexture(gl.TEXTURE_2D, null);

                // Reset cube map texture
                gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);

                // Reset 2D array texture
                gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);

                // Reset 3D texture
                gl.bindTexture(gl.TEXTURE_3D, null);
            }

            gl.activeTexture(gl.TEXTURE0);
        }

        // Pixel operations
        {
            gl.disable(gl.SCISSOR_TEST);
            gl.disable(gl.BLEND);
        }

        // Framebuffer control
        {
            gl.clearColor(0.0, 0.0, 0.0, 0.0);
        }
    };

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} format
 * @param {number} width
 * @param {number} height
 */
es3fFboColorbufferTests.FboColorClearCase = function(name, desc, format, width, height) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, format);
    this.m_width = width;
    this.m_height = height;
};

setParentClass(es3fFboColorbufferTests.FboColorClearCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboColorClearCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_format);
        return true; // No exception thrown
    };

es3fFboColorbufferTests.FboColorClearCase.prototype.render = function(dst) {
        var ctx = this.getCurrentContext();
        var fboFormat = gluTextureUtil.mapGLInternalFormat(this.m_format);
        var fmtClass = tcuTexture.getTextureChannelClass(fboFormat.type);
        var fmtInfo = tcuTextureUtil.getTextureFormatInfo(fboFormat);
        var rnd = new deRandom.Random(17);
        var numClears = 16;

        var fbo = ctx.createFramebuffer();
        var rbo = ctx.createRenderbuffer();

        ctx.bindRenderbuffer(gl.RENDERBUFFER, rbo);
        ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_width, this.m_height);
        this.checkError();

        ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
        ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
        this.checkError();
        this.checkFramebufferStatus(gl.FRAMEBUFFER);

        ctx.viewport(0, 0, this.m_width, this.m_height);

        // Initialize to transparent black.
        switch (fmtClass) {
            case tcuTexture.TextureChannelClass.FLOATING_POINT:
            case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT:
            case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT:
                ctx.clearBufferfv(gl.COLOR, 0, new Float32Array(4));
                break;

            case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER:
                ctx.clearBufferuiv(gl.COLOR, 0, new Uint32Array(4));
                break;

            case tcuTexture.TextureChannelClass.SIGNED_INTEGER:
                ctx.clearBufferiv(gl.COLOR, 0, new Int32Array(4));
                break;

            default:
                throw new Error('Invalid channelclass ' + fmtClass);
        }

        // Do random scissored clears.
        ctx.enable(gl.SCISSOR_TEST);
        for (var ndx = 0; ndx < numClears; ndx++) {
            var x = rnd.getInt(0, this.m_width - 1);
            var y = rnd.getInt(0, this.m_height - 1);
            var w = rnd.getInt(1, this.m_width - x);
            var h = rnd.getInt(1, this.m_height - y);
            var color = es3fFboColorbufferTests.randomVector(rnd, fmtInfo.valueMin, fmtInfo.valueMax);

            ctx.scissor(x, y, w, h);

            switch (fmtClass) {
                case tcuTexture.TextureChannelClass.FLOATING_POINT:
                case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT:
                case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT:
                    ctx.clearBufferfv(gl.COLOR, 0, color);
                    break;

                case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER:
                    ctx.clearBufferuiv(gl.COLOR, 0, color);
                    break;

                case tcuTexture.TextureChannelClass.SIGNED_INTEGER:
                    ctx.clearBufferiv(gl.COLOR, 0, color);
                    break;

                default:
                    throw new Error('Invalid channelclass ' + fmtClass);
            }
        }

        // Read results from renderbuffer.
        this.readPixelsUsingFormat(dst, 0, 0, this.m_width, this.m_height, fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias);
        this.checkError();
    };

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} tex0Fmt
 * @param {Array<number>} tex0Size
 * @param {number} tex1Fmt
 * @param {Array<number>} tex1Size
 */
es3fFboColorbufferTests.FboColorMultiTex2DCase = function(name, desc, tex0Fmt, tex0Size, tex1Fmt, tex1Size) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, tex0Fmt);
    this.m_tex0Fmt = tex0Fmt;
    this.m_tex0Size = tex0Size;
    this.m_tex1Fmt = tex1Fmt;
    this.m_tex1Size = tex1Size;
};

setParentClass(es3fFboColorbufferTests.FboColorMultiTex2DCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboColorMultiTex2DCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_tex0Fmt);
        this.checkFormatSupport(this.m_tex1Fmt);
        return true; // No exception thrown
    };

es3fFboColorbufferTests.FboColorMultiTex2DCase.prototype.render = function(dst) {
        var ctx = this.getCurrentContext();
        var texFmt0 = gluTextureUtil.mapGLInternalFormat(this.m_tex0Fmt);
        var texFmt1 = gluTextureUtil.mapGLInternalFormat(this.m_tex1Fmt);
        var fmtInfo0 = tcuTextureUtil.getTextureFormatInfo(texFmt0);
        var fmtInfo1 = tcuTextureUtil.getTextureFormatInfo(texFmt1);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texToFbo0Shader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt0),
            deMath.subtract(fmtInfo0.valueMax, fmtInfo0.valueMin),
            fmtInfo0.valueMin);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texToFbo1Shader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt1),
            deMath.subtract(fmtInfo1.valueMax, fmtInfo1.valueMin),
            fmtInfo1.valueMin);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var multiTexShader = new es3fFboTestUtil.Texture2DShader(
            [gluTextureUtil.getSampler2DType(texFmt0), gluTextureUtil.getSampler2DType(texFmt1)],
            gluShaderUtil.DataType.FLOAT_VEC4);

        var texToFbo0ShaderID = ctx.createProgram(texToFbo0Shader);
        var texToFbo1ShaderID = ctx.createProgram(texToFbo1Shader);
        var multiTexShaderID = ctx.createProgram(multiTexShader);

        // Setup shaders
        multiTexShader.setTexScaleBias(0, deMath.scale(fmtInfo0.lookupScale, 0.5), deMath.scale(fmtInfo0.lookupBias, 0.5));
        multiTexShader.setTexScaleBias(1, deMath.scale(fmtInfo1.lookupScale, 0.5), deMath.scale(fmtInfo1.lookupBias, 0.5));
        texToFbo0Shader.setUniforms(ctx, texToFbo0ShaderID);
        texToFbo1Shader.setUniforms(ctx, texToFbo1ShaderID);
        multiTexShader.setUniforms(ctx, multiTexShaderID);

        var fbo0 = ctx.createFramebuffer();
        var fbo1 = ctx.createFramebuffer();
        var tex0 = ctx.createTexture();
        var tex1 = ctx.createTexture();

        for (var ndx = 0; ndx < 2; ndx++) {
            var transferFmt = gluTextureUtil.getTransferFormat(ndx ? texFmt1 : texFmt0);
            var format = ndx ? this.m_tex1Fmt : this.m_tex0Fmt;
            var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(format);
            var size = ndx ? this.m_tex1Size : this.m_tex0Size;
            var fbo = ndx ? fbo1 : fbo0;
            var tex = ndx ? tex1 : tex0;

            ctx.bindTexture(gl.TEXTURE_2D, tex);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);
            ctx.texImage2D(gl.TEXTURE_2D, 0, format, size[0], size[1], 0, transferFmt.format, transferFmt.dataType, null);

            ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
            this.checkError();
            this.checkFramebufferStatus(gl.FRAMEBUFFER);
        }

        // Render textures to both framebuffers.
        for (var ndx = 0; ndx < 2; ndx++) {
            var format = gl.RGBA;
            var dataType = gl.UNSIGNED_BYTE;
            var tmpTex;
            var fbo = ndx ? fbo1 : fbo0;
            var viewport = ndx ? this.m_tex1Size : this.m_tex0Size;
            var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);

            if (ndx == 0)
                tcuTextureUtil.fillWithComponentGradients(data.getAccess(), [0, 0, 0, 0], [1, 1, 1, 1]);
            else
                tcuTextureUtil.fillWithGrid(data.getAccess(), 8, [0.2, 0.7, 0.1, 1.0], [0.7, 0.1, 0.5, 0.8]);

            tmpTex = ctx.createTexture();
            ctx.bindTexture(gl.TEXTURE_2D, tmpTex);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());

            ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            ctx.viewport(0, 0, viewport[0], viewport[1]);
            rrUtil.drawQuad(ctx, ndx ? texToFbo1ShaderID : texToFbo0ShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
        }

        // Render to framebuffer.
        ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
        ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());
        ctx.activeTexture(gl.TEXTURE0);
        ctx.bindTexture(gl.TEXTURE_2D, tex0);
        ctx.activeTexture(gl.TEXTURE1);
        ctx.bindTexture(gl.TEXTURE_2D, tex1);
        rrUtil.drawQuad(ctx, multiTexShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);

        this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight());
    };

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} texFmt
 * @param {Array<number>} texSize
 */
es3fFboColorbufferTests.FboColorTexCubeCase = function(name, desc, texFmt, texSize) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt);
    this.m_texSize = texSize;
};

setParentClass(es3fFboColorbufferTests.FboColorTexCubeCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboColorTexCubeCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_format);
        return true; // No exception thrown
    };

es3fFboColorbufferTests.FboColorTexCubeCase.prototype.render = function(dst) {
        var ctx = this.getCurrentContext();
        var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
        var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt);

        var cubeGLFaces = [
            gl.TEXTURE_CUBE_MAP_POSITIVE_X,
            gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
            gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
            gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
            gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
            gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
        ];

        var cubeTexFaces = [
            tcuTexture.CubeFace.CUBEFACE_POSITIVE_X,
            tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y,
            tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z,
            tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X,
            tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y,
            tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z
        ];

        var rnd = new deRandom.Random(21);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texToFboShader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt),
            deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin),
            fmtInfo.valueMin);

        /** @type {es3fFboTestUtil.TextureCubeShader} */
        var cubeTexShader = new es3fFboTestUtil.TextureCubeShader(
            gluTextureUtil.getSamplerCubeType(texFmt),
            gluShaderUtil.DataType.FLOAT_VEC4);

        var texToFboShaderID = ctx.createProgram(texToFboShader);
        var cubeTexShaderID = ctx.createProgram(cubeTexShader);

        // Setup shaders
        texToFboShader.setUniforms(ctx, texToFboShaderID);
        cubeTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);

        // Framebuffers.
        var fbos = [];
        var tex;

        var transferFmt = gluTextureUtil.getTransferFormat(texFmt);
        var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(this.m_format);
        var size = this.m_texSize;

        tex = ctx.createTexture();

        ctx.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
        ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);
        ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);

        // Generate an image and FBO for each cube face
        for (var ndx = 0; ndx < cubeGLFaces.length; ndx++)
            ctx.texImage2D(cubeGLFaces[ndx], 0, this.m_format, size[0], size[1], 0, transferFmt.format, transferFmt.dataType, null);
        this.checkError();

        for (var ndx = 0; ndx < cubeGLFaces.length; ndx++) {
            var layerFbo = ctx.createFramebuffer();
            ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo);
            ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, cubeGLFaces[ndx], tex, 0);
            this.checkError();
            this.checkFramebufferStatus(gl.FRAMEBUFFER);

            fbos.push(layerFbo);
        }

        // Render test images to random cube faces
        var order = [];

        for (var n = 0; n < fbos.length; n++)
            order.push(n);
        rnd.shuffle(order);

        for (var ndx = 0; ndx < 4; ndx++) {
            var face = order[ndx];
            var format = gl.RGBA;
            var dataType = gl.UNSIGNED_BYTE;
            var tmpTex;
            var fbo = fbos[face];
            var viewport = this.m_texSize;
            var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);

            tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]);

            tmpTex = ctx.createTexture();
            ctx.bindTexture(gl.TEXTURE_2D, tmpTex);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());

            ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            ctx.viewport(0, 0, viewport[0], viewport[1]);
            rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
            this.checkError();

            // Render to framebuffer
            var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0];
            var p1 = deMath.add(p0, [1.0, 1.0, 0.0]);

            ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
            ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());

            ctx.activeTexture(gl.TEXTURE0);
            ctx.bindTexture(gl.TEXTURE_CUBE_MAP, tex);

            cubeTexShader.setFace(cubeTexFaces[face]);
            cubeTexShader.setUniforms(ctx, cubeTexShaderID);

            rrUtil.drawQuad(ctx, cubeTexShaderID, p0, p1);
            this.checkError();
        }

        this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight());
    };

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} texFmt
 * @param {Array<number>} texSize
 */
es3fFboColorbufferTests.FboColorTex2DArrayCase = function(name, desc, texFmt, texSize) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt);
    this.m_texSize = texSize;
};

setParentClass(es3fFboColorbufferTests.FboColorTex2DArrayCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboColorTex2DArrayCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_format);
        return true; // No exception thrown
    };

    es3fFboColorbufferTests.FboColorTex2DArrayCase.prototype.render = function(dst) {
        var ctx = this.getCurrentContext();
        var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
        var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt);
        var rnd = new deRandom.Random(100);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texToFboShader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt),
            deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin),
            fmtInfo.valueMin);

        /** @type {es3fFboTestUtil.Texture2DArrayShader} */
        var arrayTexShader = new es3fFboTestUtil.Texture2DArrayShader(
            gluTextureUtil.getSampler2DArrayType(texFmt),
            gluShaderUtil.DataType.FLOAT_VEC4);

        var texToFboShaderID = ctx.createProgram(texToFboShader);
        var arrayTexShaderID = ctx.createProgram(arrayTexShader);

        // Setup textures
        texToFboShader.setUniforms(ctx, texToFboShaderID);
        arrayTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);

        // Framebuffers.
        var fbos = [];
        var tex;

        var transferFmt = gluTextureUtil.getTransferFormat(texFmt);
        var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(this.m_format);
        var size = this.m_texSize;

        tex = ctx.createTexture();

        ctx.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
        ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);
        ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST);
        ctx.texImage3D(gl.TEXTURE_2D_ARRAY, 0, this.m_format, size[0], size[1], size[2], 0, transferFmt.format, transferFmt.dataType, null);

        // Generate an FBO for each layer
        for (var ndx = 0; ndx < this.m_texSize[2]; ndx++) {
            var layerFbo = ctx.createFramebuffer();
            ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo);
            ctx.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex, 0, ndx);
            this.checkError();
            this.checkFramebufferStatus(gl.FRAMEBUFFER);

            fbos.push(layerFbo);
        }

        // Render test images to random texture layers
        var order = [];

        for (var n = 0; n < fbos.length; n++)
            order.push(n);
        rnd.shuffle(order);

        for (var ndx = 0; ndx < 4; ndx++) {
            var layer = order[ndx];
            var format = gl.RGBA;
            var dataType = gl.UNSIGNED_BYTE;
            var fbo = fbos[layer];
            var viewport = this.m_texSize;
            var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);

            tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]);

            var tmpTex = ctx.createTexture();
            ctx.bindTexture(gl.TEXTURE_2D, tmpTex);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());

            ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            ctx.viewport(0, 0, viewport[0], viewport[1]);
            rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
            this.checkError();

            // Render to framebuffer
            var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0];
            var p1 = deMath.add(p0, [1.0, 1.0, 0.0]);
            debug('Layer:' + layer + ' rectangle: ' + p0 + ' ' + p1);

            ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
            ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());

            ctx.activeTexture(gl.TEXTURE0);
            ctx.bindTexture(gl.TEXTURE_2D_ARRAY, tex);

            arrayTexShader.setLayer(layer);
            arrayTexShader.setUniforms(ctx, arrayTexShaderID);

            rrUtil.drawQuad(ctx, arrayTexShaderID, p0, p1);
            this.checkError();
        }

        this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight());
    };

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} texFmt
 * @param {Array<number>} texSize
 */
es3fFboColorbufferTests.FboColorTex3DCase = function(name, desc, texFmt, texSize) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt);
    this.m_texSize = texSize;
};

setParentClass(es3fFboColorbufferTests.FboColorTex3DCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboColorTex3DCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_format);
        return true; // No exception thrown
    };

    es3fFboColorbufferTests.FboColorTex3DCase.prototype.render = function(dst) {
        var ctx = this.getCurrentContext();
        var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
        var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt);
        var rnd = new deRandom.Random(100);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texToFboShader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt),
            deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin),
            fmtInfo.valueMin);

        /** @type {es3fFboTestUtil.Texture3DShader} */
        var tdTexShader = new es3fFboTestUtil.Texture3DShader(
            gluTextureUtil.getSampler3D(texFmt),
            gluShaderUtil.DataType.FLOAT_VEC4);

        var texToFboShaderID = ctx.createProgram(texToFboShader);
        var tdTexShaderID = ctx.createProgram(tdTexShader);

        // Setup textures
        texToFboShader.setUniforms(ctx, texToFboShaderID);
        tdTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);

        // Framebuffers.
        var fbos = [];
        var tex;{
            var transferFmt = gluTextureUtil.getTransferFormat(texFmt);
            var size = this.m_texSize;

            tex = ctx.createTexture();

            ctx.bindTexture(gl.TEXTURE_3D, tex);
            ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
            ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
            ctx.texImage3D(gl.TEXTURE_3D, 0, this.m_format, size[0], size[1], size[2], 0, transferFmt.format, transferFmt.dataType, null);

            // Generate an FBO for each layer
            for (var ndx = 0; ndx < this.m_texSize[2]; ndx++) {
                var layerFbo = ctx.createFramebuffer();
                ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo);
                ctx.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex, 0, ndx);
                this.checkError();
                this.checkFramebufferStatus(gl.FRAMEBUFFER);

                fbos.push(layerFbo);
            }
        }

        // Render test images to random texture layers
        var order = [];

        for (var n = 0; n < fbos.length; n++)
            order.push(n);
        rnd.shuffle(order);

        for (var ndx = 0; ndx < 4; ndx++) {
            var layer = order[ndx];
            var format = gl.RGBA;
            var dataType = gl.UNSIGNED_BYTE;
            var fbo = fbos[layer];
            var viewport = this.m_texSize;
            var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);

            tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]);

            var tmpTex = ctx.createTexture();
            ctx.bindTexture(gl.TEXTURE_2D, tmpTex);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());

            ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            ctx.viewport(0, 0, viewport[0], viewport[1]);
            rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
            this.checkError();

            // Render to framebuffer
            var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0];
            var p1 = deMath.add(p0, [1.0, 1.0, 0.0]);
            debug('Layer:' + layer + ' rectangle: ' + p0 + ' ' + p1);

            ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
            ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());

            ctx.activeTexture(gl.TEXTURE0);
            ctx.bindTexture(gl.TEXTURE_3D, tex);

            tdTexShader.setDepth(layer / (this.m_texSize[2] - 1));
            tdTexShader.setUniforms(ctx, tdTexShaderID);

            rrUtil.drawQuad(ctx, tdTexShaderID, p0, p1);
            this.checkError();
        }

        this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight());
};

/**
 * @constructor
 * @extends {es3fFboColorbufferTests.FboColorbufferCase}
 * @param {string} name
 * @param {string} desc
 * @param {number} format
 * @param {Array<number>} size
 * @param {number} funcRGB
 * @param {number} funcAlpha
 * @param {number} srcRGB
 * @param {number} dstRGB
 * @param {number} srcAlpha
 * @param {number} dstAlpha
 */
es3fFboColorbufferTests.FboBlendCase = function(name, desc, format, size, funcRGB, funcAlpha, srcRGB, dstRGB, srcAlpha, dstAlpha) {
    es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, format);
    this.m_size = size;
    this.m_funcRGB = funcRGB;
    this.m_funcAlpha = funcAlpha;
    this.m_srcRGB = srcRGB;
    this.m_dstRGB = dstRGB;
    this.m_srcAlpha = srcAlpha;
    this.m_dstAlpha = dstAlpha
};

setParentClass(es3fFboColorbufferTests.FboBlendCase, es3fFboColorbufferTests.FboColorbufferCase);

es3fFboColorbufferTests.FboBlendCase.prototype.preCheck = function() {
        this.checkFormatSupport(this.m_format);
        return true; // No exception thrown
    }

    es3fFboColorbufferTests.FboBlendCase.prototype.render = function(dst) {
        // \note Assumes floating-point or fixed-point format.
        var ctx = this.getCurrentContext();
        var fboFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
        var fmtInfo = tcuTextureUtil.getTextureFormatInfo(fboFmt);

        /** @type {es3fFboTestUtil.Texture2DShader} */
        var texShader = new es3fFboTestUtil.Texture2DShader(
            [gluShaderUtil.DataType.SAMPLER_2D], gluShaderUtil.DataType.FLOAT_VEC4);

        /** @type {es3fFboTestUtil.GradientShader} */
        var gradShader = new es3fFboTestUtil.GradientShader(gluShaderUtil.DataType.FLOAT_VEC4);

        var texShaderID = ctx.createProgram(texShader);
        var gradShaderID = ctx.createProgram(gradShader);

        // Setup shaders
        texShader.setUniforms (ctx, texShaderID);
        gradShader.setGradient(ctx, gradShaderID, [0, 0, 0, 0], [1, 1, 1, 1]);

        var fbo = ctx.createFramebuffer();
        var rbo = ctx.createRenderbuffer();

        ctx.bindRenderbuffer(gl.RENDERBUFFER, rbo);
        ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_size[0], this.m_size[1]);
        this.checkError();

        ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
        ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
        this.checkError();
        this.checkFramebufferStatus(gl.FRAMEBUFFER);

        ctx.viewport(0, 0, this.m_size[0], this.m_size[1]);

        // Fill framebuffer with grid pattern.
        var format = gl.RGBA;
        var dataType = gl.UNSIGNED_BYTE;
        var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);

        tcuTextureUtil.fillWithGrid(data.getAccess(), 8, [0.2, 0.7, 0.1, 1.0], [0.7, 0.1, 0.5, 0.8]);

        var gridTex = ctx.createTexture();
        ctx.bindTexture(gl.TEXTURE_2D, gridTex);
        ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
        ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
        ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
        ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());

        rrUtil.drawQuad(ctx, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
        this.checkError();

        // Setup blend.
        ctx.enable(gl.BLEND);
        ctx.blendEquationSeparate(this.m_funcRGB, this.m_funcAlpha);
        ctx.blendFuncSeparate(this.m_srcRGB, this.m_dstRGB, this.m_srcAlpha, this.m_dstAlpha);

        // Render gradient with blend.
        rrUtil.drawQuad(ctx, gradShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);

        es3fFboTestUtil.readPixels(ctx, dst, 0, 0, this.m_size[0], this.m_size[1], fboFmt, [1, 1, 1, 1], [0, 0, 0, 0]);
    };

/**
 * @constructor
 * @extends {tcuTestCase.DeqpTest}
 */
es3fFboColorbufferTests.FboColorbufferTests = function() {
    tcuTestCase.DeqpTest.call(this, 'color', 'Colorbuffer tests');
};

setParentClass(es3fFboColorbufferTests.FboColorbufferTests, tcuTestCase.DeqpTest);

es3fFboColorbufferTests.FboColorbufferTests.prototype.init = function() {
    var colorFormats = [
        // RGBA formats
        gl.RGBA32I,
        gl.RGBA32UI,
        gl.RGBA16I,
        gl.RGBA16UI,
        gl.RGBA8,
        gl.RGBA8I,
        gl.RGBA8UI,
        gl.SRGB8_ALPHA8,
        gl.RGB10_A2,
        gl.RGB10_A2UI,
        gl.RGBA4,
        gl.RGB5_A1,

        // RGB formats
        gl.RGB8,
        gl.RGB565,

        // RG formats
        gl.RG32I,
        gl.RG32UI,
        gl.RG16I,
        gl.RG16UI,
        gl.RG8,
        gl.RG8I,
        gl.RG8UI,

        // R formats
        gl.R32I,
        gl.R32UI,
        gl.R16I,
        gl.R16UI,
        gl.R8,
        gl.R8I,
        gl.R8UI,

        // gl.EXT_color_buffer_float
        gl.RGBA32F,
        gl.RGBA16F,
        gl.R11F_G11F_B10F,
        gl.RG32F,
        gl.RG16F,
        gl.R32F,
        gl.R16F,

        // gl.EXT_color_buffer_half_float is not exposed in WebGL 2.0.
        // gl.RGB16F
    ];

    // .clear
    var clearGroup = tcuTestCase.newTest("clear", "Color clears");
    this.addChild(clearGroup);

    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        clearGroup.addChild(new es3fFboColorbufferTests.FboColorClearCase(
            es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texNpotSizeA[0], texNpotSizeA[1]));
    }

    var numGroups = 6;

    // .tex2d
    var tex2DGroup = [];
    for (var ii = 0; ii < numGroups; ++ii) {
        tex2DGroup[ii] = tcuTestCase.newTest("tex2d", "Texture 2D tests");
        this.addChild(tex2DGroup[ii]);
    }
    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        tex2DGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorMultiTex2DCase(
            es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texNpotSizeA, colorFormats[ndx], texNpotSizeB));
    }

    // .texcube
    var texCubeGroup = [];
    for (var ii = 0; ii < numGroups; ++ii) {
        texCubeGroup[ii] = tcuTestCase.newTest("texcube", "Texture cube map tests");
        this.addChild(texCubeGroup[ii]);
    }
    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        texCubeGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTexCubeCase(
            es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize));
    }

    // .tex2darray
    var tex2DArrayGroup = [];
    for (var ii = 0; ii < numGroups; ++ii) {
        tex2DArrayGroup[ii] = tcuTestCase.newTest("tex2darray", "Texture 2D array tests");
        this.addChild(tex2DArrayGroup[ii]);
    }
    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        tex2DArrayGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTex2DArrayCase(
            es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize));
    }

    // .tex3d
    var tex3DGroup = [];
    for (var ii = 0; ii < numGroups; ++ii) {
        tex3DGroup[ii] = tcuTestCase.newTest("tex3d", "Texture 3D tests");
        this.addChild(tex3DGroup[ii]);
    }
    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        tex3DGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTex3DCase(
            es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize));
    }

    // .blend
    var blendGroup = tcuTestCase.newTest("blend", "Blending tests");
    this.addChild(blendGroup);

    for (var ndx = 0; ndx < colorFormats.length; ndx++) {
        var format = colorFormats[ndx];
        var texFmt = gluTextureUtil.mapGLInternalFormat(format);
        var fmtClass = tcuTexture.getTextureChannelClass(texFmt.type);
        var fmtName = es3fFboTestUtil.getFormatName(format);

        if (texFmt.type == tcuTexture.ChannelType.FLOAT ||
            fmtClass == tcuTexture.TextureChannelClass.SIGNED_INTEGER ||
            fmtClass == tcuTexture.TextureChannelClass.UNSIGNED_INTEGER)
            continue; // Blending is not supported.

        blendGroup.addChild(new es3fFboColorbufferTests.FboBlendCase(fmtName + "_src_over", "", format,
            texNpotSizeA, gl.FUNC_ADD, gl.FUNC_ADD, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE));
    }
};

/**
* Run test
* @param {WebGL2RenderingContext} context
*/
es3fFboColorbufferTests.run = function(context, range) {
    gl = context;

    const canvas = gl.canvas;
    canvas.width = canvasWH;
    canvas.height = canvasWH;

    //Set up Test Root parameters
    var state = tcuTestCase.runner;
    state.setRoot(new es3fFboColorbufferTests.FboColorbufferTests());

    //Set up name and description of this test series.
    setCurrentTestName(state.testCases.fullName());
    description(state.testCases.getDescription());

    try {
        if (range)
            state.setRange(range);
        //Run test cases
        tcuTestCase.runTestCases();
    }
    catch (err) {
        testFailedOptions('Failed to es3fFboColorbufferTests.run tests', false);
        tcuTestCase.runner.terminate();
    }
};

});