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

goog.scope(function() {

var es3fFragmentOutputTests = functional.gles3.es3fFragmentOutputTests;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var deRandom = framework.delibs.debase.deRandom;
var tcuTestCase = framework.common.tcuTestCase;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var tcuTexture = framework.common.tcuTexture;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var deMath = framework.delibs.debase.deMath;
var tcuImageCompare = framework.common.tcuImageCompare;

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

    var DE_ASSERT = function(x) {
        if (!x)
            throw new Error('Assert failed');
    };

    /**
     * es3fFragmentOutputTests.BufferSpec. Constructs the es3fFragmentOutputTests.BufferSpec object
     * @constructor
     * @param {WebGLRenderingContextBase.GLenum} format_
     * @param {number} width_
     * @param {number} height_
     * @param {number} samples_
     */
    es3fFragmentOutputTests.BufferSpec = function(format_, width_, height_, samples_) {
        this.format = format_;
        this.width = width_;
        this.height = height_;
        this.samples = samples_;
    };

    /**
     * es3fFragmentOutputTests.FragmentOutput. Constructs the es3fFragmentOutputTests.FragmentOutput object
     * @constructor
     * @param {gluShaderUtil.DataType} type_
     * @param {gluShaderUtil.precision} precision_
     * @param {number} location_
     * @param {number=} arrayLength_
     */
    es3fFragmentOutputTests.FragmentOutput = function(type_, precision_, location_, arrayLength_) {
        this.type = type_;
        this.precision = precision_;
        this.location = location_;
        this.arrayLength = arrayLength_ || 0;
    };

    /**
     * es3fFragmentOutputTests.FragmentOutputCase. Constructs the es3fFragmentOutputTests.FragmentOutputCase object
     * @constructor
     * @extends {tcuTestCase.DeqpTest}
     * @param {string} name
     * @param {string} description
     * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
     * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
     * @return {Object} The currently modified object
     */
    es3fFragmentOutputTests.FragmentOutputCase = function(name, description, fboSpec, outputs) {
        tcuTestCase.DeqpTest.call(this, name, description);
        /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ this.m_fboSpec = fboSpec;
        /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ this.m_outputs = outputs;
        /** @type {gluShaderProgram.ShaderProgram} */ this.m_program = null;
        /** @type {WebGLFramebuffer} */ this.m_framebuffer = null;

        /** @type {WebGLRenderbuffer} */ this.m_renderbuffer = null;
    };

    es3fFragmentOutputTests.FragmentOutputCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
    es3fFragmentOutputTests.FragmentOutputCase.prototype.constructor = es3fFragmentOutputTests.FragmentOutputCase;

    /**
     * es3fFragmentOutputTests.createProgram. Returns a ShaderProgram object
     * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
     * @return {gluShaderProgram.ShaderProgram} program
     */
    es3fFragmentOutputTests.createProgram = function(outputs) {

        var vtx = '';
        var frag = '';

        vtx = '#version 300 es\n' + 'in highp vec4 a_position;\n';
        frag = '#version 300 es\n';

    /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output = null;
    /** @type {boolean} */ var isArray = false;
     // Input-output declarations.
        for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
            output = outputs[outNdx];
            isArray = output.arrayLength > 0;
            /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(output.type);
            /** @type {string} */ var precName = gluShaderUtil.getPrecisionName(output.precision);
            /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
            /** @type {string} */ var interp = isFloat ? 'smooth' : 'flat';

            if (isArray) {
                for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
                    vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + '_' + elemNdx + ';\n' +
                    interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
                    frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
                }
                frag += 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + '[' + output.arrayLength + '];\n';
            } else {
                vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + ';\n' +
                interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + ';\n';
                frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + ';\n' +
                'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + ';\n';
            }
        }

        vtx += '\nvoid main()\n{\n';
        frag += '\nvoid main()\n{\n';

        vtx += ' gl_Position = a_position;\n';

        // Copy body
        for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
            output = outputs[outNdx];
            isArray = output.arrayLength > 0;

            if (isArray) {
                for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
                    vtx += '\tvar' + outNdx + '_' + elemNdx + ' = in' + outNdx + '_' + elemNdx + ';\n';
                    frag += '\tout' + outNdx + '[' + elemNdx + '] = var' + outNdx + '_' + elemNdx + ';\n';
                }
            } else {
                vtx += '\tvar' + outNdx + ' = in' + outNdx + ';\n';
                frag += '\tout' + outNdx + ' = var' + outNdx + ';\n';
            }
        }

        vtx += '}\n';
        frag += '}\n';

        /** @type {gluShaderProgram.ShaderProgram} */
        var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtx, frag));
        return program;
    };

    es3fFragmentOutputTests.FragmentOutputCase.prototype.init = function() {
        // Check that all attachments are supported
        for (var iter = 0; iter < this.m_fboSpec.length; ++iter) {
            if (!gluTextureUtil.isSizedFormatColorRenderable(this.m_fboSpec[iter].format))
                throw new Error('Unsupported attachment format');
        }

        DE_ASSERT(!this.m_program);
        this.m_program = es3fFragmentOutputTests.createProgram(this.m_outputs);

       // log << *m_program;
        if (!this.m_program.isOk())
            throw new Error('Compile failed. Program no created');

        /*
        // Print render target info to log.
        log << TestLog::Section("Framebuffer", "Framebuffer configuration");

        for (int ndx = 0; ndx < (int)m_fboSpec.size(); ndx++)
            log << TestLog::Message << "COLOR_ATTACHMENT" << ndx << ": "
                                    << glu::getPixelFormatStr(m_fboSpec[ndx].format) << ", "
                                    << m_fboSpec[ndx].width << "x" << m_fboSpec[ndx].height << ", "
                                    << m_fboSpec[ndx].samples << " samples"
                << TestLog::EndMessage;

        log << TestLog::EndSection;*/

        // Create framebuffer.
        this.m_framebuffer = gl.createFramebuffer();
        gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);

        for (var bufNdx = 0; bufNdx < /* m_renderbuffers.size() */ this.m_fboSpec.length; bufNdx++) {
            this.m_renderbuffer = gl.createRenderbuffer();
            /** @type {es3fFragmentOutputTests.BufferSpec} */ var bufSpec = this.m_fboSpec[bufNdx];
            /** @type {number} */ var attachment = gl.COLOR_ATTACHMENT0 + bufNdx;

            gl.bindRenderbuffer(gl.RENDERBUFFER, this.m_renderbuffer);

            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, bufSpec.samples, bufSpec.format, bufSpec.width, bufSpec.height);
            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, this.m_renderbuffer);
        }
        /** @type {number} */ var fboStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER);

        if (fboStatus == gl.FRAMEBUFFER_UNSUPPORTED)
            throw new Error('Framebuffer not supported');
        else if (fboStatus != gl.FRAMEBUFFER_COMPLETE)
            throw new Error('Incomplete framebuffer');
            // throw tcu::TestError((string("Incomplete framebuffer: ") + glu::getFramebufferStatusStr(fboStatus), "", __FILE__, __LINE__);

        // gl.bindRenderbuffer(gl.RENDERBUFFER, null); // TODO: maybe needed?
        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
    };

    es3fFragmentOutputTests.FragmentOutputCase.prototype.deinit = function() {
        // TODO: implement?
    };

    /**
     * es3fFragmentOutputTests.getMinSize.
     * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
     * @return {Array<number>} minSize
     */
    es3fFragmentOutputTests.getMinSize = function(fboSpec) {
        /** @type {Array<number>} */ var minSize = [0x7fffffff, 0x7fffffff];
        for (var i = 0; i < fboSpec.length; i++) {
            minSize[0] = Math.min(minSize[0], fboSpec[i].width);
            minSize[1] = Math.min(minSize[1], fboSpec[i].height);
        }
        return minSize;
    };

    /**
     * es3fFragmentOutputTests.getNumInputVectors. Returns the length of the array of all the outputs (es3fFragmentOutputTests.FragmentOutput object)
     * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
     * @return {number} numVecs
     */
    es3fFragmentOutputTests.getNumInputVectors = function(outputs) {
        /** @type {number} */ var numVecs = 0;
        for (var i = 0; i < outputs.length; i++)
            numVecs += (outputs[i].arrayLength > 0 ? outputs[i].arrayLength : 1);
        return numVecs;
    };

    /**
     * es3fFragmentOutputTests.getFloatRange
     * @param {gluShaderUtil.precision} precision
     * @return {Array<number>} Vec2
     */
    es3fFragmentOutputTests.getFloatRange = function(precision) {
        /** @type {Array<Array<number>>} */
        var ranges = // Vec2
        [
            [-2.0, 2.0],
            [-16000.0, 16000.0],
            [-1e35, 1e35]
        ];
        // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
        // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
        return ranges[precision];
    };

    /**
     * es3fFragmentOutputTests.getIntRange
     * @param {gluShaderUtil.precision} precision
     * @return {Array<number>} IVec2
     */
    es3fFragmentOutputTests.getIntRange = function(precision) {
        /** @type {Array<Array<number>>} */
        var ranges = // IVec2
        [
            [-(1 << 7), (1 << 7) - 1],
            [-(1 << 15), (1 << 15) - 1],
            [-0x80000000, 0x7fffffff]
        ];
        // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
        // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
        return ranges[precision];
    };

    /**
     * es3fFragmentOutputTests.getUintRange
     * @param {gluShaderUtil.precision} precision
     * @return {Array<number>} UVec2
     */
    es3fFragmentOutputTests.getUintRange = function(precision) {
        /** @type {Array<Array<number>>} */
        var ranges = // UVec2
        [
            [0, (1 << 8) - 1],
            [0, (1 << 16) - 1],
            [0, 0xffffffff]
        ];
        // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
        // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
        return ranges[precision];

    };

    /**
     * es3fFragmentOutputTests.readVec4
     * @param {Array<number>} ptr
     * @param {number} index
     * @param {number} numComponents
     * @return {Array<number>} Vec4
     */
    es3fFragmentOutputTests.readVec4 = function(ptr, index, numComponents) {
        DE_ASSERT(numComponents >= 1);
        return [
                ptr[index + 0],
                numComponents >= 2 ? ptr[index + 1] : 0.0,
                numComponents >= 3 ? ptr[index + 2] : 0.0,
                numComponents >= 4 ? ptr[index + 3] : 0.0
                ];
    };

    /**
     * es3fFragmentOutputTests.readIVec4
     * @param {Array<number>} ptr
     * @param {number} numComponents
     * @return {Array<number>} IVec4
     */
    es3fFragmentOutputTests.readIVec4 = function(ptr, index, numComponents) {
        DE_ASSERT(numComponents >= 1);
        return [
                ptr[index + 0],
                numComponents >= 2 ? ptr[index + 1] : 0,
                numComponents >= 3 ? ptr[index + 2] : 0,
                numComponents >= 4 ? ptr[index + 3] : 0
                ];
    };

    /**
     * es3fFragmentOutputTests.renderFloatReference
     * @param {tcuTexture.PixelBufferAccess} dst
     * @param {number} gridWidth
     * @param {number} gridHeight
     * @param {number} numComponents
     * @param {Array<number>} vertices
     */
    es3fFragmentOutputTests.renderFloatReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {

        /** @type {boolean} */ var isSRGB = dst.getFormat().order == tcuTexture.ChannelOrder.sRGB || dst.getFormat().order == tcuTexture.ChannelOrder.sRGBA;
        /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
        /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);

        for (var y = 0; y < dst.getHeight(); y++) {
            for (var x = 0; x < dst.getWidth(); x++) {
                /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
                /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
                /** @type {number} */ var xf = (x - cellX * cellW + 0.5) / cellW;
                /** @type {number} */ var yf = (y - cellY * cellH + 0.5) / cellH;

                /** @type {Array<number>} */ var v00 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
                /** @type {Array<number>} */ var v01 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
                /** @type {Array<number>} */ var v10 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4
                /** @type {Array<number>} */ var v11 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4

                /** @type {boolean} */ var tri = xf + yf >= 1.0;
                /** @type {Array<number>} */ var v0 = tri ? v11 : v00; // Vec4&
                /** @type {Array<number>} */ var v1 = tri ? v01 : v10; // Vec4&
                /** @type {Array<number>} */ var v2 = tri ? v10 : v01; // Vec4&
                /** @type {number} */ var s = tri ? 1.0 - xf : xf;
                /** @type {number} */ var t = tri ? 1.0 - yf : yf;
                /** @type {Array<number>} */ var color = deMath.add(v0, deMath.add(deMath.multiply((deMath.subtract(v1, v0)), [s, s, s, s]), deMath.multiply((deMath.subtract(v2, v0)), [t, t, t, t]))); // Vec4

                dst.setPixel(isSRGB ? tcuTextureUtil.linearToSRGB(color) : color, x, y);
            }
        }
    };

    /**
     * es3fFragmentOutputTests.renderIntReference
     * @param {tcuTexture.PixelBufferAccess} dst
     * @param {number} gridWidth
     * @param {number} gridHeight
     * @param {number} numComponents
     * @param {Array<number>} vertices
     */
    es3fFragmentOutputTests.renderIntReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {

        /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
        /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);

        for (var y = 0; y < dst.getHeight(); y++) {
            for (var x = 0; x < dst.getWidth(); x++) {
                /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
                /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
                /** @type {Array<number>} */ var c = es3fFragmentOutputTests.readIVec4(vertices, (cellY * gridWidth + cellX + 1) * numComponents, numComponents); // IVec4

                dst.setPixelInt(c, x, y);
            }
        }
    };

    /**
     * es3fFragmentOutputTests.s_swizzles
     * @return {Array<Array<number>>}
     */
    es3fFragmentOutputTests.s_swizzles = function() {
        var mat_swizzles = [
            [0, 1, 2, 3],
            [1, 2, 3, 0],
            [2, 3, 0, 1],
            [3, 0, 1, 2],
            [3, 2, 1, 0],
            [2, 1, 0, 3],
            [1, 0, 3, 2],
            [0, 3, 2, 1]
        ];

        return mat_swizzles;
    };

    /**
     * es3fFragmentOutputTests.swizzleVec. Returns an Array from a position contained in the Array es3fFragmentOutputTests.s_swizzles []
     * @param {Array<number>} vec
     * @param {number} swzNdx
     * @return {Array<number>} Swizzled array
     */
    es3fFragmentOutputTests.swizzleVec = function(vec, swzNdx) {
    /** @type {Array<number>} */ var swz = es3fFragmentOutputTests.s_swizzles()[swzNdx % es3fFragmentOutputTests.s_swizzles().length];

        return deMath.swizzle(vec, swz);
    };

    /**
     * es3fFragmentOutputTests.AttachmentData struct class
     * @constructor
     * @return {Object}
     */
    es3fFragmentOutputTests.AttachmentData = function() {
        return {
        /** @type {tcuTexture.TextureFormat} */ format: null, //!< Actual format of attachment.
        /** @type {tcuTexture.TextureFormat} */ referenceFormat: null, //!< Used for reference rendering.
        /** @type {tcuTexture.TextureFormat} */ readFormat: null,
        /** @type {number} */ numWrittenChannels: 0,
        /** @type {gluShaderUtil.precision} */ outPrecision: gluShaderUtil.precision.PRECISION_LOWP,
        /** @type {ArrayBuffer} */ renderedData: null,
        /** @type {ArrayBuffer} */ referenceData: null
        };
    };

    es3fFragmentOutputTests.FragmentOutputCase.prototype.iterate = function() {
        // Compute grid size & index list.
        /** @type {number} */ var minCellSize = 8;
        /** @type {Array<number>} */ var minBufSize = es3fFragmentOutputTests.getMinSize(this.m_fboSpec); // IVec2
        /** @type {number} */ var gridWidth = deMath.clamp(Math.floor(minBufSize[0] / minCellSize), 1, 255) + 1;
        /** @type {number} */ var gridHeight = deMath.clamp(Math.floor(minBufSize[1] / minCellSize), 1, 255) + 1;
        /** @type {number} */ var numVertices = gridWidth * gridHeight;
        /** @type {number} */ var numQuads = (gridWidth - 1) * (gridHeight - 1);
        /** @type {number} */ var numIndices = numQuads * 6;

        /** @type {number} */ var numInputVecs = es3fFragmentOutputTests.getNumInputVectors(this.m_outputs);
        /** @type {Array<Array<number>>} */ var inputs = []; // originally vector<vector<deUint32>

        for (var inputNdx = 0; inputNdx < numInputVecs; inputNdx++)
            inputs[inputNdx] = []; // inputs.length = numInputVecs;

        /** @type {Array<number>} */ var positions = []; // originally vector<float>
        /** @type {Array<number>} */ var indices = []; // originally vector<deUint16>

        /** @type {number} */ var readAlignment = 4;
        /** @type {number} */ var viewportW = minBufSize[0];
        /** @type {number} */ var viewportH = minBufSize[1];
        /** @type {number} */ var numAttachments = this.m_fboSpec.length;

        /** @type {Array<number>} */ var drawBuffers = []; // originally vector<deUint32>
        /** @type {Array<es3fFragmentOutputTests.AttachmentData>} */ var attachments = [];
        /** @type {number} */ var attachmentW;
        /** @type {number} */ var attachmentH;

        // Initialize attachment data.
        for (var ndx = 0; ndx < numAttachments; ndx++) {
            /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_fboSpec[ndx].format);
            /** @type {tcuTexture.TextureChannelClass} */ var chnClass = tcuTexture.getTextureChannelClass(texFmt.type);
            /** @type {boolean} */ var isFixedPoint = (chnClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT ||
                                                              chnClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT);

            // \note Fixed-point formats use float reference to enable more accurate result verification.
            /** @type {tcuTexture.TextureFormat} */ var refFmt = isFixedPoint ? new tcuTexture.TextureFormat(texFmt.order, tcuTexture.ChannelType.FLOAT) : texFmt;
            /** @type {tcuTexture.TextureFormat} */ var readFmt = es3fFboTestUtil.getFramebufferReadFormat(texFmt);
            attachmentW = this.m_fboSpec[ndx].width;
            attachmentH = this.m_fboSpec[ndx].height;

            drawBuffers[ndx] = gl.COLOR_ATTACHMENT0 + ndx;
            attachments[ndx] = new es3fFragmentOutputTests.AttachmentData();
            attachments[ndx].format = texFmt;
            attachments[ndx].readFormat = readFmt;
            attachments[ndx].referenceFormat = refFmt;
            attachments[ndx].renderedData = new ArrayBuffer(readFmt.getPixelSize() * attachmentW * attachmentH);
            attachments[ndx].referenceData = new ArrayBuffer(refFmt.getPixelSize() * attachmentW * attachmentH);
        }

        // Initialize indices.
        for (var quadNdx = 0; quadNdx < numQuads; quadNdx++) {
            /** @type {number} */ var quadY = Math.floor(quadNdx / (gridWidth - 1));
            /** @type {number} */ var quadX = quadNdx - quadY * (gridWidth - 1);

            indices[quadNdx * 6 + 0] = quadX + quadY * gridWidth;
            indices[quadNdx * 6 + 1] = quadX + (quadY + 1) * gridWidth;
            indices[quadNdx * 6 + 2] = quadX + quadY * gridWidth + 1;
            indices[quadNdx * 6 + 3] = indices[quadNdx * 6 + 1];
            indices[quadNdx * 6 + 4] = quadX + (quadY + 1) * gridWidth + 1;
            indices[quadNdx * 6 + 5] = indices[quadNdx * 6 + 2];
        }

        /** @type {number} */ var xf = 0;
        /** @type {number} */ var yf = 0;
        for (var y = 0; y < gridHeight; y++) {
            for (var x = 0; x < gridWidth; x++) {
                xf = x / (gridWidth - 1);
                yf = y / (gridHeight - 1);

                positions[(y * gridWidth + x) * 4 + 0] = 2.0 * xf - 1.0;
                positions[(y * gridWidth + x) * 4 + 1] = 2.0 * yf - 1.0;
                positions[(y * gridWidth + x) * 4 + 2] = 0.0;
                positions[(y * gridWidth + x) * 4 + 3] = 1.0;
            }
        }
        /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output;
        /** @type {boolean} */ var isArray;
        /** @type {boolean} */ var isFloat;
        /** @type {boolean} */ var isInt;
        /** @type {boolean} */ var isUint;
        /** @type {number} */ var numVecs;
        /** @type {number} */ var numScalars;

        var curInVec = 0;
        for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
            output = this.m_outputs[outputNdx];
            isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
            isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
            isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
            numVecs = output.arrayLength > 0 ? output.arrayLength : 1;
            numScalars = gluShaderUtil.getDataTypeScalarSize(output.type);

            for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
                inputs[curInVec].length = numVertices * numScalars;

                // Record how many outputs are written in attachment.
                DE_ASSERT(output.location + vecNdx < attachments.length);
                attachments[output.location + vecNdx].numWrittenChannels = numScalars;
                attachments[output.location + vecNdx].outPrecision = output.precision;

                /** @type {Array<number>} */ var range = null;
                /** @type {Array<number>} */ var minVal = null;
                /** @type {Array<number>} */ var maxVal = null;
                /** @type {Array<number>} */ var fmtBits = null;
                /** @type {Array<number>} */ var fmtMaxVal = [];
                /** @type {Array<number>} */ var rangeDiv = null;
                /** @type {Array<number>} */ var step = [];
                /** @type {number} */ var ix = 0;
                /** @type {number} */ var iy = 0;
                /** @type {Array<number>} */ var c = null;
                /** @type {number} */ var pos = 0;
               if (isFloat) {
                    range = es3fFragmentOutputTests.getFloatRange(output.precision); // Vec2
                    minVal = [range[0], range[0], range[0], range[0]]; // Vec4
                    maxVal = [range[1], range[1], range[1], range[1]]; // Vec4

                    if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
                    // \note Floating-point precision conversion is not well-defined. For that reason we must
                    // limit value range to intersection of both data type and render target value ranges.
                    /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(attachments[output.location + vecNdx].format);
                        minVal = deMath.max(minVal, fmtInfo.valueMin);
                        maxVal = deMath.min(maxVal, fmtInfo.valueMax);
                    }

                    bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);

                    for (var y = 0; y < gridHeight; y++) {
                        for (var x = 0; x < gridWidth; x++) {
                            xf = x / (gridWidth - 1);
                            yf = y / (gridHeight - 1);
                            /** @type {number} */ var f0 = (xf + yf) * 0.5;
                            /** @type {number} */ var f1 = 0.5 + (xf - yf) * 0.5;

                            /** @type {Array<number>} */ var f = es3fFragmentOutputTests.swizzleVec([f0, f1, 1.0 - f0, 1.0 - f1], curInVec); // Vec4
                            c = deMath.add(minVal, deMath.multiply(deMath.subtract(maxVal, minVal), f)); // Vec4

                            pos = (y * gridWidth + x) * numScalars;

                            for (var ndx = 0; ndx < numScalars; ndx++)
                                inputs[curInVec][pos + ndx] = c[ndx];
                        }
                    }
                } else if (isInt) {
                    range = es3fFragmentOutputTests.getIntRange(output.precision); // IVec2
                    minVal = [range[0], range[0], range[0], range[0]]; // IVec4
                    maxVal = [range[1], range[1], range[1], range[1]]; // IVec4

                    if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
                        // Limit to range of output format as conversion mode is not specified.
                        fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4
                        /** @type {Array<boolean>} */ var isZero = deMath.lessThanEqual(fmtBits, [0, 0, 0, 0]); // BVec4, array of booleans, size = 4

                        /** @type {Array<number>} */ var fmtMinVal = []; // IVec4

                        for (var i = 0; i < 4; i++) {

                            // const IVec4 fmtMinVal = (-(tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>())).asInt();
                            fmtMinVal[i] = -1 * Math.pow(2, fmtBits[i] - 1); // TODO: check implementation, original above
                            // const IVec4 fmtMaxVal = ((tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>()) - deInt64(1)).asInt();
                            fmtMaxVal[i] = Math.pow(2, fmtBits[i] - 1) - 1; // TODO: check implementation, original above
                        }

                        minVal = tcuTextureUtil.select(minVal, deMath.max(minVal, fmtMinVal), isZero);
                        maxVal = tcuTextureUtil.select(maxVal, deMath.min(maxVal, fmtMaxVal), isZero);
                    }

                    bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);

                    rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4
                    for (var i = 0; i < 4; i++) {
                        // const IVec4 step = ((maxVal.cast<deInt64>() - minVal.cast<deInt64>()) / (rangeDiv.cast<deInt64>())).asInt();
                        step[i] = Math.floor((maxVal[i] - minVal[i]) / rangeDiv[i]); // TODO: check with the above line of code
                    }

                    for (var y = 0; y < gridHeight; y++) {
                        for (var x = 0; x < gridWidth; x++) {
                            ix = gridWidth - x - 1;
                            iy = gridHeight - y - 1;
                            c = deMath.add(minVal, deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec))); // IVec4

                            pos = (y * gridWidth + x) * numScalars;

                            for (var ndx = 0; ndx < numScalars; ndx++)
                                inputs[curInVec][pos + ndx] = c[ndx];
                        }
                    }
                } else if (isUint) {
                    range = es3fFragmentOutputTests.getUintRange(output.precision); // UVec2
                    maxVal = [range[1], range[1], range[1], range[1]]; // UVec4

                    if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
                        // Limit to range of output format as conversion mode is not specified.
                        fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4

                        for (var i = 0; i < 4; i++) {
                            fmtMaxVal[i] = Math.pow(2, fmtBits[i]) - 1;
                        }

                        maxVal = deMath.min(maxVal, fmtMaxVal);
                    }

                    bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);

                    rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4

                    for (var stepPos = 0; stepPos < maxVal.length; stepPos++) {
                        step[stepPos] = Math.floor(maxVal[stepPos] / rangeDiv[stepPos]);
                    }

                    DE_ASSERT(range[0] == 0);

                    for (var y = 0; y < gridHeight; y++) {
                        for (var x = 0; x < gridWidth; x++) {
                            ix = gridWidth - x - 1;
                            iy = gridHeight - y - 1;
                            c = deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec)); // UVec4
                            pos = (y * gridWidth + x) * numScalars;

                            DE_ASSERT(deMath.boolAll(deMath.lessThanEqual(c, maxVal))); // TODO: sometimes crashes here, condition not asserted

                            for (var ndx = 0; ndx < numScalars; ndx++)
                                inputs[curInVec][pos + ndx] = c[ndx];
                        }
                    }
                } else
                    DE_ASSERT(false);

                curInVec += 1;
            }
        }

        // Render using gl.
        gl.useProgram(this.m_program.getProgram());
        gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
        gl.viewport(0, 0, viewportW, viewportH);
        gl.drawBuffers(drawBuffers);
        gl.disable(gl.DITHER); // Dithering causes issues with unorm formats. Those issues could be worked around in threshold, but it makes validation less accurate.

        /** @type {WebGLBuffer} */ var buffer = null;
        /** @type {string} */ var name;
        curInVec = 0;
        for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
            output = this.m_outputs[outputNdx];
            isArray = output.arrayLength > 0;
            isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
            isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
            isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
            /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
            /** @type {number} */ var glScalarType = isFloat ? /* gluShaderUtil.DataType.FLOAT */ gl.FLOAT :
                                                     isInt ? /* gluShaderUtil.DataType.INT */ gl.INT :
                                                     isUint ? /* gluShaderUtil.DataType.UINT */ gl.UNSIGNED_INT : /* gluShaderUtil.DataType.INVALID */ gl.NONE;
            numVecs = isArray ? output.arrayLength : 1;

            for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
                name = 'in' + outputNdx + (isArray ? '_' + vecNdx : '');
                /** @type {number} */ var loc = gl.getAttribLocation(this.m_program.getProgram(), name);

                if (loc >= 0) {
                    buffer = gl.createBuffer();
                    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);

                    gl.enableVertexAttribArray(loc);
                    if (isFloat) {
                        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(inputs[curInVec]), gl.STATIC_DRAW);
                        // KHRONOS WebGL 1.0 specification:
                        // void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
                        gl.vertexAttribPointer(loc, scalarSize, glScalarType, false, 0, 0); // offset = 0
                    } else {
                        gl.bufferData(gl.ARRAY_BUFFER, new Int32Array(inputs[curInVec]), gl.STATIC_DRAW);
                        // KHRONOS WebGL 2.0 specification:
                        // void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
                        gl.vertexAttribIPointer(loc, scalarSize, glScalarType, 0, 0); // offset = 0
                    }
                } else
                    bufferedLogToConsole('Warning: No location for attribute "' + name + '" found.');

                curInVec += 1;
            }
        }

        /** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
        // TCU_CHECK(posLoc >= 0);
        buffer = gl.createBuffer();
        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);

        gl.enableVertexAttribArray(posLoc);
        gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); // offset = 0

        /** @type {WebGLBuffer} */ var indexObject = gl.createBuffer();
        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexObject);
        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);

        gl.drawElements(gl.TRIANGLES, numIndices, gl.UNSIGNED_SHORT, 0); // offset = 0

        // Render reference images.

        var curInNdx = 0;
        for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
            output = this.m_outputs[outputNdx];
            isArray = output.arrayLength > 0;
            isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
            isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
            isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
            scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
            numVecs = isArray ? output.arrayLength : 1;

            for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
                /** @type {number} */ var location = output.location + vecNdx;
                /** @type {Array<number>} */ var inputData = inputs[curInNdx];

                DE_ASSERT(deMath.deInBounds32(location, 0, this.m_fboSpec.length));

                /** @type {number} */ var bufW = this.m_fboSpec[location].width;
                /** @type {number} */ var bufH = this.m_fboSpec[location].height;
                /** @type {Object} */ var descriptor = {
                        format: attachments[location].referenceFormat,
                        width: bufW,
                        height: bufH,
                        depth: 1,
                        data: attachments[location].referenceData // ArrayBuffer
                };
                /** @type {tcuTexture.PixelBufferAccess} */ var buf = new tcuTexture.PixelBufferAccess(descriptor);
                /** @type {tcuTexture.PixelBufferAccess} */ var viewportBuf = tcuTextureUtil.getSubregion(buf, 0, 0, 0, viewportW, viewportH, 1);

                if (isInt || isUint)
                    es3fFragmentOutputTests.renderIntReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
                else if (isFloat)
                    es3fFragmentOutputTests.renderFloatReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
                else
                    DE_ASSERT(false);

                curInNdx += 1;
            }
        }

        // Compare all images.
        /** @type {boolean} */ var allLevelsOk = true;
        for (var attachNdx = 0; attachNdx < numAttachments; attachNdx++) {
            attachmentW = this.m_fboSpec[attachNdx].width;
            attachmentH = this.m_fboSpec[attachNdx].height;
            /** @type {number} */ var numValidChannels = attachments[attachNdx].numWrittenChannels;
            /** @type {Array<boolean>} */ var cmpMask = [numValidChannels >= 1, numValidChannels >= 2, numValidChannels >= 3, numValidChannels >= 4];
            /** @type {gluShaderUtil.precision} */ var outPrecision = attachments[attachNdx].outPrecision;
            /** @type {tcuTexture.TextureFormat} */ var format = attachments[attachNdx].format;
            /** @type {Object} */
            var renderedDescriptor = {
                    format: attachments[attachNdx].readFormat,
                    width: attachmentW,
                    height: attachmentH,
                    depth: 1,
                    rowPitch: deMath.deAlign32(attachments[attachNdx].readFormat.getPixelSize() * attachmentW, readAlignment),
                    slicePitch: 0,
                    data: attachments[attachNdx].renderedData // ArrayBuffer
            };
            /** @type {tcuTexture.PixelBufferAccess} */ var rendered = new tcuTexture.PixelBufferAccess(renderedDescriptor);
            /** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(attachments[attachNdx].readFormat);
            gl.readBuffer(gl.COLOR_ATTACHMENT0 + attachNdx);
            gl.readPixels(0, 0, attachmentW, attachmentH, transferFmt.format, transferFmt.dataType, rendered.getDataPtr());

            /** @type {Object} */
            var referenceDescriptor = {
                    format: attachments[attachNdx].referenceFormat,
                    width: attachmentW,
                    height: attachmentH,
                    depth: 1,
                    data: attachments[attachNdx].referenceData // ArrayBuffer
            };
            /** @type {tcuTexture.ConstPixelBufferAccess} */ var reference = new tcuTexture.ConstPixelBufferAccess(referenceDescriptor);
            /** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(format.type);
            /** @type {boolean} */ var isOk = true;
            name = 'Attachment ' + attachNdx;
            /** @type {string} */ var desc = 'Color attachment ' + attachNdx;
            /** @type {Array<number>} */ var threshold;

            bufferedLogToConsole('Attachment ' + attachNdx + ': ' + numValidChannels + ' channels have defined values and used for comparison');

            switch (texClass) {
                case tcuTexture.TextureChannelClass.FLOATING_POINT: {
                    /** @type {Array<number>} */ var formatThreshold = []; // UVec4 //!< Threshold computed based on format.
                    formatThreshold.length = 4;
                    /** @type {number} */ var precThreshold = 0; // deUint32 //!< Threshold computed based on output type precision
                    /** @type {Array<number>} */ var finalThreshold = []; // UVec4
                    finalThreshold.length = 4;

                    switch (format.type) {
                        case tcuTexture.ChannelType.FLOAT:
                            formatThreshold = [4, 4, 4, 4]; // UVec4
                            break;
                        case tcuTexture.ChannelType.HALF_FLOAT:
                            formatThreshold = [(1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4]; // UVec4
                            break;
                        case tcuTexture.ChannelType.UNSIGNED_INT_11F_11F_10F_REV:
                            formatThreshold = [(1 << 17) + 4, (1 << 17) + 4, (1 << 18) + 4, 4]; // UVec4
                            break;
                        default:
                            DE_ASSERT(false);
                            break;
                    }

                    switch (outPrecision) {
                        case gluShaderUtil.precision.PRECISION_LOWP:
                            precThreshold = (1 << 21);
                            break;
                        case gluShaderUtil.precision.PRECISION_MEDIUMP:
                            precThreshold = (1 << 13);
                            break;
                        case gluShaderUtil.precision.PRECISION_HIGHP:
                            precThreshold = 0;
                            break;
                        default:
                            DE_ASSERT(false);
                    }

                    finalThreshold = tcuTextureUtil.select(
                                    deMath.max(formatThreshold, [precThreshold, precThreshold, precThreshold, precThreshold]),
                                    [0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff], // C++ version: UVec4(~0u) bitwise not, all bits in the integer will be flipped
                                    cmpMask);

                    isOk = tcuImageCompare.floatUlpThresholdCompare(name, desc, reference, rendered, finalThreshold /*, tcu::COMPARE_LOG_RESULT*/);
                    break;
                }

                case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: {
                    // \note glReadPixels() allows only 8 bits to be read. This means that RGB10_A2 will loose some
                    // bits in the process and it must be taken into account when computing threshold.
                    /** @type {Array<number>} */ var bits = deMath.min([8, 8, 8, 8], tcuTextureUtil.getTextureFormatBitDepth(format)); // IVec4

                    /** @type {Array<number>} */ var baseThreshold = []; // Vec4
                    baseThreshold.length = 4;
                    for (var inc = 0; inc < baseThreshold.length; inc++) {
                        // TODO: check the operation below: baseThreshold = 1.0f / ((IVec4(1) << bits)-1).asFloat();
                        baseThreshold[inc] = 1.0 / ((1 << bits[inc]) - 1);
                    }

                    threshold = tcuTextureUtil.select(baseThreshold, [2.0, 2.0, 2.0, 2.0], cmpMask); // Vec4

                    isOk = tcuImageCompare.floatThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
                    break;
                }

                case tcuTexture.TextureChannelClass.SIGNED_INTEGER:
                case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: {
                    // The C++ dEQP code uses ~0u but ~0 is -1 in Javascript
                    var UINT_MAX = Math.pow(2.0, 32.0) - 1;
                    threshold = tcuTextureUtil.select(
                                    [0, 0, 0, 0],
                                    [UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX],
                                    cmpMask
                                    ); // UVec4
                    isOk = tcuImageCompare.intThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
                    break;
                }

                default:
                    testFailedOptions('Unsupported comparison', true);
                    break;
            }

            if (!isOk)
                allLevelsOk = false;
        }

        if (numAttachments > 1) {
            if (allLevelsOk)
                testPassed('Image comparison passed for ' +  numAttachments + ' attachments');
            else
                testFailed('Image comparison failed for some of ' +  numAttachments + ' attachments');
        } else {
            if (allLevelsOk)
                testPassed('Image comparison passed');
            else
                testFailed('Image comparison failed');
        }

        return tcuTestCase.IterateResult.STOP;
    };

    /**
     * es3fFragmentOutputTests.createRandomCase. Constructs the es3fFragmentOutputTests.createRandomCase, child class of es3fFragmentOutputTests.FragmentOutputCase
     * @constructor
     * @param {number} minRenderTargets
     * @param {number} maxRenderTargets
     * @param {number} seed
     * @return {es3fFragmentOutputTests.FragmentOutputCase} The currently modified object
     */
    es3fFragmentOutputTests.createRandomCase = function(minRenderTargets, maxRenderTargets, seed, colorBufferFloatSupported) {

        /** @type {Array<gluShaderUtil.DataType>} */
        var outputTypes = [
                           gluShaderUtil.DataType.FLOAT,
                           gluShaderUtil.DataType.FLOAT_VEC2,
                           gluShaderUtil.DataType.FLOAT_VEC3,
                           gluShaderUtil.DataType.FLOAT_VEC4,
                           gluShaderUtil.DataType.INT,
                           gluShaderUtil.DataType.INT_VEC2,
                           gluShaderUtil.DataType.INT_VEC3,
                           gluShaderUtil.DataType.INT_VEC4,
                           gluShaderUtil.DataType.UINT,
                           gluShaderUtil.DataType.UINT_VEC2,
                           gluShaderUtil.DataType.UINT_VEC3,
                           gluShaderUtil.DataType.UINT_VEC4
                           ];

        /** @type {Array<gluShaderUtil.precision>} */
        var precisions = [
                          gluShaderUtil.precision.PRECISION_LOWP,
                          gluShaderUtil.precision.PRECISION_MEDIUMP,
                          gluShaderUtil.precision.PRECISION_HIGHP
                          ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var floatFormats = [
                            gl.RGBA32F,
                            gl.RGBA16F,
                            gl.R11F_G11F_B10F,
                            gl.RG32F,
                            gl.RG16F,
                            gl.R32F,
                            gl.R16F,
                            gl.RGBA8,
                            gl.SRGB8_ALPHA8,
                            gl.RGB10_A2,
                            gl.RGBA4,
                            gl.RGB5_A1,
                            gl.RGB8,
                            gl.RGB565,
                            gl.RG8,
                            gl.R8
                            ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var colorBufferFloatFormats = [
                                       gl.RGBA32F,
                                       gl.RGBA16F,
                                       gl.R11F_G11F_B10F,
                                       gl.RG32F,
                                       gl.RG16F,
                                       gl.R32F,
                                       gl.R16F
        ];


        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var intFormats = [
                            gl.RGBA32I,
                            gl.RGBA16I,
                            gl.RGBA8I,
                            gl.RG32I,
                            gl.RG16I,
                            gl.RG8I,
                            gl.R32I,
                            gl.R16I,
                            gl.R8I
                            ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var uintFormats = [
                           gl.RGBA32UI,
                           gl.RGBA16UI,
                           gl.RGBA8UI,
                           gl.RGB10_A2UI,
                           gl.RG32UI,
                           gl.RG16UI,
                           gl.RG8UI,
                           gl.R32UI,
                           gl.R16UI,
                           gl.R8UI
                           ];

        /** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed);
        /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ var outputs = [];
        /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var targets = [];
        /** @type {Array<gluShaderUtil.DataType>} */ var outTypes = [];

        /** @type {number} */ var numTargets = rnd.getInt(minRenderTargets, maxRenderTargets);
        /** @type {number} */ var width = 128; // \todo [2012-04-10 pyry] Separate randomized sizes per target?
        /** @type {number} */ var height = 64;
        /** @type {number} */ var samples = 0;

        // Compute outputs.
        /** @type {number} */ var curLoc = 0;
        while (curLoc < numTargets) {
            /** @type {boolean} */ var useArray = rnd.getFloat() < 0.3;
            /** @type {number} */ var maxArrayLen = numTargets - curLoc;
            /** @type {number} */ var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 0;
            /** @type {Array<gluShaderUtil.DataType>} */ var basicTypeArray = rnd.choose(outputTypes, undefined, 1);
            /** @type {gluShaderUtil.DataType} */ var basicType = basicTypeArray[0];
            /** @type {Array<gluShaderUtil.precision>} */ var precisionArray = rnd.choose(precisions, undefined, 1);
            /** @type {gluShaderUtil.precision} */ var precision = precisionArray[0];
            /** @type {number} */ var numLocations = useArray ? arrayLen : 1;

            outputs.push(new es3fFragmentOutputTests.FragmentOutput(basicType, precision, curLoc, arrayLen));

            for (var ndx = 0; ndx < numLocations; ndx++)
                outTypes.push(basicType);

            curLoc += numLocations;
        }
        DE_ASSERT(curLoc == numTargets);
        DE_ASSERT(outTypes.length == numTargets);

        // Compute buffers.
        while (targets.length < numTargets) {
            /** @type {gluShaderUtil.DataType} */ var outType = outTypes[targets.length];
            /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(outType);
            /** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(outType);
            /** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(outType);
            /** @type {Array} */ var formatArray = [];
            /** @type {number} */ var format = 0;

            if (isFloat) {
                formatArray = rnd.choose(floatFormats, undefined, 1);
                format = formatArray[0];
                if (colorBufferFloatFormats.indexOf(format) >= 0 && !colorBufferFloatSupported)
                    return null;
            } else if (isInt) {
                formatArray = rnd.choose(intFormats, undefined, 1);
                format = formatArray[0];
            } else if (isUint) {
                formatArray = rnd.choose(uintFormats, undefined, 1);
                format = formatArray[0];
            } else
                DE_ASSERT(false);

            targets.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
        }

        return new es3fFragmentOutputTests.FragmentOutputCase(seed.toString(), '', targets, outputs);

    };

    es3fFragmentOutputTests.init = function(gl) {
        var state = tcuTestCase.runner;
        state.testCases = tcuTestCase.newTest('fragment_outputs', 'Top level');
        /** @const @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases;

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var requiredFloatFormats = [
            gl.RGBA32F,
            gl.RGBA16F,
            gl.R11F_G11F_B10F,
            gl.RG32F,
            gl.RG16F,
            gl.R32F,
            gl.R16F
        ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var requiredFixedFormats = [
            gl.RGBA8,
            gl.SRGB8_ALPHA8,
            gl.RGB10_A2,
            gl.RGBA4,
            gl.RGB5_A1,
            gl.RGB8,
            gl.RGB565,
            gl.RG8,
            gl.R8
        ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var requiredIntFormats = [
            gl.RGBA32I,
            gl.RGBA16I,
            gl.RGBA8I,
            gl.RG32I,
            gl.RG16I,
            gl.RG8I,
            gl.R32I,
            gl.R16I,
            gl.R8I
        ];

        /** @type {Array<WebGLRenderingContextBase.GLenum>} */
        var requiredUintFormats = [
            gl.RGBA32UI,
            gl.RGBA16UI,
            gl.RGBA8UI,
            gl.RGB10_A2UI,
            gl.RG32UI,
            gl.RG16UI,
            gl.RG8UI,
            gl.R32UI,
            gl.R16UI,
            gl.R8UI
        ];

        /** @type {Array<gluShaderUtil.precision>} */
        var precisions = [

            gluShaderUtil.precision.PRECISION_LOWP,
            gluShaderUtil.precision.PRECISION_MEDIUMP,
            gluShaderUtil.precision.PRECISION_HIGHP

        ];

     // .basic.

        /** @const @type {number} */ var width = 64;
        /** @const @type {number} */ var height = 64;
        /** @const @type {number} */ var samples = 0;
        /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var fboSpec = null;
        /** @type {gluShaderUtil.precision} */ var prec;
        /** @type {string} */ var precName;

    // .float
        if (gl.getExtension('EXT_color_buffer_float')) {
            /** @type {tcuTestCase.DeqpTest} */ var floatGroup = tcuTestCase.newTest('basic.float', 'Floating-point output tests');
            testGroup.addChild(floatGroup);

            for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
                var format = requiredFloatFormats[fmtNdx];
                var fmtName = es3fFboTestUtil.getFormatName(format);
                fboSpec = [];

                fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

                for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                    prec = precisions[precNdx];
                    precName = gluShaderUtil.getPrecisionName(prec);

                    // NOTE: Eliminated original OutputVec and toVec(), as it only returned an element of the outputs array in OutputVec
                    floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
                    floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
                    floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
                    floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
                }
            }
        }

        // .fixed
        /** @type {tcuTestCase.DeqpTest} */ var fixedGroup = tcuTestCase.newTest('basic.fixed', 'Fixed-point output tests');
        testGroup.addChild(fixedGroup);
        for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
            var format = requiredFixedFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
                fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
                fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
                fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
            }
        }

        // .int
        /** @type {tcuTestCase.DeqpTest} */ var intGroup = tcuTestCase.newTest('basic.int', 'Integer output tests');
        testGroup.addChild(intGroup);
        for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
            var format = requiredIntFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0)]));
                intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0)]));
                intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0)]));
                intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0)]));
            }
        }

        // .uint
        /** @type {tcuTestCase.DeqpTest} */ var uintGroup = tcuTestCase.newTest('basic.uint', 'Usigned integer output tests');
        testGroup.addChild(uintGroup);
        for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
            var format = requiredUintFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0)]));
                uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0)]));
                uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0)]));
                uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0)]));

            }
        }

     // .array

        /** @type {number} */ var numTargets = 3;

        // .float
        if (gl.getExtension('EXT_color_buffer_float')) {
            /** @type {tcuTestCase.DeqpTest} */ var arrayFloatGroup = tcuTestCase.newTest('array.float', 'Floating-point output tests');
            testGroup.addChild(arrayFloatGroup);
            for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
                var format = requiredFloatFormats[fmtNdx];
                var fmtName = es3fFboTestUtil.getFormatName(format);
                fboSpec = [];

                for (var ndx = 0; ndx < numTargets; ndx++)
                    fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

                for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                    prec = precisions[precNdx];
                    precName = gluShaderUtil.getPrecisionName(prec);

                    arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
                    arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
                    arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
                    arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
                }
            }
        }

        // .fixed
        /** @type {tcuTestCase.DeqpTest} */ var arrayFixedGroup = tcuTestCase.newTest('array.fixed', 'Fixed-point output tests');
        testGroup.addChild(arrayFixedGroup);
        for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
            var format = requiredFixedFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            for (var ndx = 0; ndx < numTargets; ndx++)
                fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
                arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
                arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
                arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
            }
        }

        // .int
        /** @type {tcuTestCase.DeqpTest} */ var arrayIntGroup = tcuTestCase.newTest('array.int', 'Integer output tests');
        testGroup.addChild(arrayIntGroup);
        for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
            var format = requiredIntFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            for (var ndx = 0; ndx < numTargets; ndx++)
                fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0, numTargets)]));
                arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0, numTargets)]));
                arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0, numTargets)]));
                arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0, numTargets)]));
            }
        }

        // .uint
        /** @type {tcuTestCase.DeqpTest} */ var arrayUintGroup = tcuTestCase.newTest('array.uint', 'Usigned integer output tests');
        testGroup.addChild(arrayUintGroup);
        for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
            var format = requiredUintFormats[fmtNdx];
            var fmtName = es3fFboTestUtil.getFormatName(format);
            fboSpec = [];

            for (var ndx = 0; ndx < numTargets; ndx++)
                fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));

            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
                prec = precisions[precNdx];
                precName = gluShaderUtil.getPrecisionName(prec);

                arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0, numTargets)]));
                arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0, numTargets)]));
                arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0, numTargets)]));
                arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0, numTargets)]));
            }
        }

    // .random

        /** @type {Array<tcuTestCase.DeqpTest>} */ var randomGroup = [];
        var numRandomGroups = 3;
        for (var ii = 0; ii < numRandomGroups; ++ii) {
            randomGroup[ii] = tcuTestCase.newTest('random', 'Random fragment output cases');
            testGroup.addChild(randomGroup[ii]);
        }

        /** @type {boolean} */ var colorBufferFloatSupported = (gl.getExtension('EXT_color_buffer_float') != null);
        for (var seed = 0; seed < 100; seed++) {
            var test = es3fFragmentOutputTests.createRandomCase(2, 4, seed, colorBufferFloatSupported);
            if (test !== null) {
                randomGroup[seed % numRandomGroups].addChild(test);
            }
        }

    };

    /**
     * Create and execute the test cases
     */
    es3fFragmentOutputTests.run = function(context, range) {
        gl = context;
      //Set up Test Root parameters
        var testName = 'fragment_output';
        var testDescription = 'Fragment Output Tests';
        var state = tcuTestCase.runner;

        state.testName = testName;
        state.testCases = tcuTestCase.newTest(testName, testDescription, null);

      //Set up name and description of this test series.
        setCurrentTestName(testName);
        description(testDescription);

        try {
            es3fFragmentOutputTests.init(gl);
            if (range)
                state.setRange(range);
            tcuTestCase.runTestCases();
        } catch (err) {
            testFailedOptions('Failed to es3fFragmentOutputTests.run tests', false);
            bufferedLogToConsole(err);
            tcuTestCase.runner.terminate();
        }

    };

});