/*-------------------------------------------------------------------------
 * 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('modules.shared.glsShaderLibraryCase');
goog.require('framework.common.tcuTestCase');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');

goog.scope(function() {

var glsShaderLibraryCase = modules.shared.glsShaderLibraryCase;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;

    /** @const @type {number} */ glsShaderLibraryCase.VIEWPORT_WIDTH = 128;
    /** @const @type {number} */ glsShaderLibraryCase.VIEWPORT_HEIGHT = 128;

/**
 * Shader compilation expected result enum
 * @enum {number}
 */
glsShaderLibraryCase.expectResult = {
    EXPECT_PASS: 0,
    EXPECT_COMPILE_FAIL: 1,
    EXPECT_LINK_FAIL: 2,
    EXPECT_COMPILE_LINK_FAIL: 3,
    EXPECT_VALIDATION_FAIL: 4,
    EXPECT_BUILD_SUCCESSFUL: 5
};

/**
 * Test case type
 * @enum {number}
 */
glsShaderLibraryCase.caseType = {
    CASETYPE_COMPLETE: 0, //!< Has all shaders specified separately.
    CASETYPE_VERTEX_ONLY: 1, //!< "Both" case, vertex shader sub case.
    CASETYPE_FRAGMENT_ONLY: 2 //!< "Both" case, fragment shader sub case.
};

/**
 * glsShaderLibraryCase.BeforeDrawValidator target type enum
 * @enum {number}
 */
glsShaderLibraryCase.targetType = {
    PROGRAM: 0,
    PIPELINE: 1
};

/**
 * Shader case type enum
 * @enum {number}
 */
glsShaderLibraryCase.shaderCase = {
    STORAGE_INPUT: 0,
    STORAGE_OUTPUT: 1,
    STORAGE_UNIFORM: 2
};

/**
 * Checks if shader uses in/out qualifiers depending on the version
 * @param {string} version
 * @return {boolean} version
 */
glsShaderLibraryCase.usesShaderInoutQualifiers = function(version) {
    switch (version) {
        case '100':
        case '130':
        case '140':
        case '150':
            return false;

        default:
            return true;
    }
};

/**
 * Checks if version supports fragment highp precision
 * @param {string} version
 * @return {boolean} version ,True when is different from version 100
 */
glsShaderLibraryCase.supportsFragmentHighp = function(version) {
    return version !== '100';
};

/**
 * This functions builds a matching vertex shader for a 'both' case, when
 * the fragment shader is being tested.
 * We need to build attributes and varyings for each 'input'.
 * @param { {values:Array}} valueBlock
 * @return {string} res
 */
glsShaderLibraryCase.genVertexShader = function(valueBlock) {
    /** @type {string} */ var res = '';
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
    /** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';

    res += '#version ' + state.currentTest.spec.targetVersion + '\n';
    res += 'precision highp float;\n';
    res += 'precision highp int;\n';
    res += '\n';
    res += vtxIn + ' highp vec4 dEQP_Position;\n';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
        var val = valueBlock.values[ndx];
        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
            /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
            res += vtxIn + ' ' + floatType + ' a_' + val.valueName + ';\n';

            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                res += vtxOut + ' ' + floatType + ' ' + val.valueName + ';\n';
            else
                res += vtxOut + ' ' + floatType + ' v_' + val.valueName + ';\n';
        }
    }
    res += '\n';

    // Main function.
    // - gl_Position = dEQP_Position;
    // - for each input: write attribute directly to varying
    res += 'void main()\n';
    res += ' {\n';
    res += '\tgl_Position = dEQP_Position;\n';
    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
        var val = valueBlock.values[ndx];
        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
        /** @type {string} */ var name = val.valueName;
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                res += '\t' + name + ' = a_' + name + ';\n';
            else
                res += '\tv_' + name + ' = a_' + name + ';\n';
        }
    }

    res += '}\n';
    return res;
};

/**
 * @param { {values:Array}} valueBlock
 * @param {boolean} useFloatTypes
 * @return {string} stream
 */
glsShaderLibraryCase.genCompareFunctions = function(valueBlock, useFloatTypes) {
    var cmpTypeFound = {};
    /** @type {string} */ var stream = '';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT)
            cmpTypeFound[gluShaderUtil.getDataTypeName(val.dataType)] = true;

    }
    if (useFloatTypes) {
        if (cmpTypeFound['bool']) stream += 'bool isOk (float a, bool b) { return ((a > 0.5) == b); }\n';
        if (cmpTypeFound['bvec2']) stream += 'bool isOk (vec2 a, bvec2 b) { return (greaterThan(a, vec2(0.5)) == b); }\n';
        if (cmpTypeFound['bvec3']) stream += 'bool isOk (vec3 a, bvec3 b) { return (greaterThan(a, vec3(0.5)) == b); }\n';
        if (cmpTypeFound['bvec4']) stream += 'bool isOk (vec4 a, bvec4 b) { return (greaterThan(a, vec4(0.5)) == b); }\n';
        if (cmpTypeFound['int']) stream += 'bool isOk (float a, int b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1)); }\n';
        if (cmpTypeFound['ivec2']) stream += 'bool isOk (vec2 a, ivec2 b) { return (ivec2(floor(a + 0.5)) == b); }\n';
        if (cmpTypeFound['ivec3']) stream += 'bool isOk (vec3 a, ivec3 b) { return (ivec3(floor(a + 0.5)) == b); }\n';
        if (cmpTypeFound['ivec4']) stream += 'bool isOk (vec4 a, ivec4 b) { return (ivec4(floor(a + 0.5)) == b); }\n';
        if (cmpTypeFound['uint']) stream += 'bool isOk (float a, uint b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1u)); }\n';
        if (cmpTypeFound['uvec2']) stream += 'bool isOk (vec2 a, uvec2 b) { return (uvec2(floor(a + 0.5)) == b); }\n';
        if (cmpTypeFound['uvec3']) stream += 'bool isOk (vec3 a, uvec3 b) { return (uvec3(floor(a + 0.5)) == b); }\n';
        if (cmpTypeFound['uvec4']) stream += 'bool isOk (vec4 a, uvec4 b) { return (uvec4(floor(a + 0.5)) == b); }\n';
    } else {
        if (cmpTypeFound['bool']) stream += 'bool isOk (bool a, bool b) { return (a == b); }\n';
        if (cmpTypeFound['bvec2']) stream += 'bool isOk (bvec2 a, bvec2 b) { return (a == b); }\n';
        if (cmpTypeFound['bvec3']) stream += 'bool isOk (bvec3 a, bvec3 b) { return (a == b); }\n';
        if (cmpTypeFound['bvec4']) stream += 'bool isOk (bvec4 a, bvec4 b) { return (a == b); }\n';
        if (cmpTypeFound['int']) stream += 'bool isOk (int a, int b) { return (a == b); }\n';
        if (cmpTypeFound['ivec2']) stream += 'bool isOk (ivec2 a, ivec2 b) { return (a == b); }\n';
        if (cmpTypeFound['ivec3']) stream += 'bool isOk (ivec3 a, ivec3 b) { return (a == b); }\n';
        if (cmpTypeFound['ivec4']) stream += 'bool isOk (ivec4 a, ivec4 b) { return (a == b); }\n';
        if (cmpTypeFound['uint']) stream += 'bool isOk (uint a, uint b) { return (a == b); }\n';
        if (cmpTypeFound['uvec2']) stream += 'bool isOk (uvec2 a, uvec2 b) { return (a == b); }\n';
        if (cmpTypeFound['uvec3']) stream += 'bool isOk (uvec3 a, uvec3 b) { return (a == b); }\n';
        if (cmpTypeFound['uvec4']) stream += 'bool isOk (uvec4 a, uvec4 b) { return (a == b); }\n';
    }

    if (cmpTypeFound['float'])
        stream += 'bool isOk (float a, float b, float eps) { return (abs(a-b) <= (eps*abs(b) + eps)); }\n';
    if (cmpTypeFound['vec2'])
        stream += 'bool isOk (vec2 a, vec2 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';
    if (cmpTypeFound['vec3'])
        stream += 'bool isOk (vec3 a, vec3 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';
    if (cmpTypeFound['vec4'])
        stream += 'bool isOk (vec4 a, vec4 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';

    if (cmpTypeFound['mat2'])
        stream += 'bool isOk (mat2 a, mat2 b, float eps) { vec2 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec2(eps))); }\n';
    if (cmpTypeFound['mat2x3'])
        stream += 'bool isOk (mat2x3 a, mat2x3 b, float eps) { vec3 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec3(eps))); }\n';
    if (cmpTypeFound['mat2x4'])
        stream += 'bool isOk (mat2x4 a, mat2x4 b, float eps) { vec4 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec4(eps))); }\n';
    if (cmpTypeFound['mat3x2'])
        stream += 'bool isOk (mat3x2 a, mat3x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec2(eps))); }\n';
    if (cmpTypeFound['mat3'])
        stream += 'bool isOk (mat3 a, mat3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec3(eps))); }\n';
    if (cmpTypeFound['mat3x4'])
        stream += 'bool isOk (mat3x4 a, mat3x4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec4(eps))); }\n';
    if (cmpTypeFound['mat4x2'])
        stream += 'bool isOk (mat4x2 a, mat4x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec2(eps))); }\n';
    if (cmpTypeFound['mat4x3'])
        stream += 'bool isOk (mat4x3 a, mat4x3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec3(eps))); }\n';
    if (cmpTypeFound['mat4'])
        stream += 'bool isOk (mat4 a, mat4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec4(eps))); }\n';

    return stream;
};

/**
 * @param {string} dstVec4Var
 * @param { {values:Array}} valueBlock
 * @param {string} nonFloatNamePrefix
 * @param {?string=} checkVarName
 * @return {string} output
 */
glsShaderLibraryCase.genCompareOp = function(dstVec4Var, valueBlock, nonFloatNamePrefix, checkVarName) {

    /** @type {boolean} */ var isFirstOutput = true;
    /** @type {string} */ var output = '';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var valueName = val.valueName;

        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
            // Check if we're only interested in one variable (then skip if not the right one).
            if (checkVarName && (valueName !== checkVarName))
                continue;

            // Prefix.
            if (isFirstOutput) {
                output += 'bool RES = ';
                isFirstOutput = false;
            } else
                output += 'RES = RES && ';

            // Generate actual comparison.
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                output += 'isOk(' + valueName + ', ref_' + valueName + ', 0.05);\n';
            else
                output += 'isOk(' + nonFloatNamePrefix + valueName + ', ref_' + valueName + ');\n';
        }
        // \note Uniforms are already declared in shader.
    }

    if (isFirstOutput)
        output += dstVec4Var + ' = vec4(1.0);\n'; // \todo [petri] Should we give warning if not expect-failure case?
    else
        output += dstVec4Var + ' = vec4(RES, RES, RES, 1.0);\n';

    return output;
};

/**
 * @param { {values:Array}} valueBlock
 * @return {string} shader
 */
glsShaderLibraryCase.genFragmentShader = function(valueBlock) {
    /** @type {string} */ var shader = '';
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
    /** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';
    /** @type {boolean} */ var customColorOut = usesInout;
    /** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
    /** @type {string} */ var prec = glsShaderLibraryCase.supportsFragmentHighp(state.currentTest.spec.targetVersion) ? 'highp' : 'mediump';

    shader += '#version ' + state.currentTest.spec.targetVersion + '\n';

    shader += 'precision ' + prec + ' float;\n';
    shader += 'precision ' + prec + ' int;\n';
    shader += '\n';

    if (customColorOut) {
        shader += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
        shader += '\n';
    }

    shader += glsShaderLibraryCase.genCompareFunctions(valueBlock, true);
    shader += '\n';

    // Declarations (varying, reference for each output).
    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
    /** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);

        if (val.storageType == glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                shader += fragIn + ' ' + floatType + ' ' + val.valueName + ';\n';
            else
                shader += fragIn + ' ' + floatType + ' v_' + val.valueName + ';\n';

            shader += 'uniform ' + refType + ' ref_' + val.valueName + ';\n';
        }
    }

    shader += '\n';
    shader += 'void main()\n';
    shader += ' {\n';

    shader += '\t';
    shader += glsShaderLibraryCase.genCompareOp(customColorOut ? 'dEQP_FragColor' : 'gl_FragColor', valueBlock, 'v_', null);

    shader += '}\n';
    return shader;
};

glsShaderLibraryCase.caseRequirement = (function() {

/**
 * @constructor
 */
var CaseRequirement = function() {

/**
 * @param {number} shaderType
 * @return {boolean}
 */
    this.isAffected = function(shaderType) {
        for (var i = 0; i < this.shaderTypes.length; i++)
            if (this.shaderTypes[i] === shaderType)
                return true;
        return false;
    };

    this.checkRequirements = function(gl) {
        if (this.type === requirementType.EXTENSION) {
            var extns = gl.getSupportedExtensions();
            for (var i = 0; i < extns.length; i++)
                for (var j = 0; j < this.requirements.length; j++)
                    if (extns[i] === this.requirements[j]) {
                        this.supportedExtension = this.requirements[j];
                        return true;
                    }
            if (this.requirements.length === 1)
                throw Error('Test requires extension of ' + this.requirements[0]);
            else
                throw Error('Test requires any extension of ' + this.requirements);
        } else if (this.type === requirementType.IMPLEMENTATION_LIMIT) {
            var value = gl.getParameter(this.enumName);
            assertMsgOptions(gl.getError() === gl.NO_ERROR, 'Failed to read parameter ' + this.enumName, false, true);

            if (!(value > this.referenceValue))
                throw Error('Test requires ' + this.enumName + ' (' + value + ') > ' + this.referenceValue);
        }
    };

    this.getSupportedExtension = function() {
        return this.supportedExtension;
    };

};

var createAnyExtensionRequirement = function(requirements, shaderTypes) {
    var cr = new CaseRequirement();
    cr.type = requirementType.EXTENSION;
    cr.requirements = requirements;
    cr.shaderTypes = shaderTypes;
    return cr;
};

var createLimitRequirement = function(enumName, ref) {
    var cr = new CaseRequirement();
    cr.type = requirementType.IMPLEMENTATION_LIMIT;
    cr.enumName = enumName;
    cr.referenceValue = ref;
};

/**
 * @enum {number}
 */
var requirementType = {
    EXTENSION: 0,
    IMPLEMENTATION_LIMIT: 1
};

return {
    createAnyExtensionRequirement: createAnyExtensionRequirement,
    createLimitRequirement: createLimitRequirement,
    requirementType: requirementType
};

}());

/** Specialize a shader only for the vertex test case.
 * @param {string} baseCode
 * @param {number} shaderType
 * @param {Array<Object>} requirements
 * @return {string} resultBuf
 */
glsShaderLibraryCase.injectExtensionRequirements = function(baseCode, shaderType, requirements) {
/**
 * @param {Array<Object>} requirements
 * @param {number} shaderType
 * @return {string} buf
 */
    var generateExtensionStatements = function(requirements, shaderType) {
        /** @type {string} */ var buf = '';

        if (requirements)
            for (var ndx = 0; ndx < requirements.length; ndx++)
                if (requirements[ndx].type === glsShaderLibraryCase.caseRequirement.requirementType.EXTENSION &&
                    requirements[ndx].isAffected(shaderType))
                    buf += '#extension ' + requirements[ndx].getSupportedExtension() + ' : require\n';

        return buf;
    };

    /** @type {string} */ var extensions = generateExtensionStatements(requirements, shaderType);

    if (extensions.length === 0)
        return baseCode;

    /** @type {Array<string>} */ var splitLines = baseCode.split('\n');
    /** @type {boolean} */ var firstNonPreprocessorLine = true;
    /** @type {string} */ var resultBuf = '';

    for (var i = 0; i < splitLines.length; i++) {
        /** @const @type {boolean} */ var isPreprocessorDirective = (splitLines[i].match(/^\s*#/) !== null);

        if (!isPreprocessorDirective && firstNonPreprocessorLine) {
            firstNonPreprocessorLine = false;
            resultBuf += extensions;
        }

        resultBuf += splitLines[i] + '\n';
    }

    return resultBuf;
};

/** Specialize a shader for the vertex shader test case.
 * @param {string} src
 * @param { {values:Array}} valueBlock
 * @return {string} withExt
 */
glsShaderLibraryCase.specializeVertexShader = function(src, valueBlock) {
    /** @type {string} */ var decl = '';
    /** @type {string} */ var setup = '';
    /** @type {string} */ var output = '';
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
    /** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';

    // Output (write out position).
    output += 'gl_Position = dEQP_Position;\n';

    // Declarations (position + attribute for each input, varying for each output).
    decl += vtxIn + ' highp vec4 dEQP_Position;\n';
    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var valueName = val.valueName;
    /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
    /** @type {string} */ var dataTypeName = gluShaderUtil.getDataTypeName(val.dataType);

        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float') {
                decl += vtxIn + ' ' + floatType + ' ' + valueName + ';\n';
            } else {
                decl += vtxIn + ' ' + floatType + ' a_' + valueName + ';\n';
                setup += dataTypeName + ' ' + valueName + ' = ' + dataTypeName + '(a_' + valueName + ');\n';
            }
        } else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                decl += vtxOut + ' ' + floatType + ' ' + valueName + ';\n';
            else {
                decl += vtxOut + ' ' + floatType + ' v_' + valueName + ';\n';
                decl += dataTypeName + ' ' + valueName + ';\n';

                output += 'v_' + valueName + ' = ' + floatType + '(' + valueName + ');\n';
            }
        }
    }

    /** @type {string} */
    var baseSrc = src
                    .replace(/\$\{DECLARATIONS\}/g, decl)
                    .replace(/\$\{DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
                    .replace(/\$\{SETUP\}/g, setup)
                    .replace(/\$\{OUTPUT\}/g, output)
                    .replace(/\$\{POSITION_FRAG_COLOR\}/g, 'gl_Position');

    /** @type {string} */
    var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.VERTEX, state.currentTest.spec.requirements);

    return withExt;
};

/** Specialize a shader only for the vertex test case.
 * @param {string} src
 * @param { {values:Array}} valueBlock
 * @return {string} withExt
 */
glsShaderLibraryCase.specializeVertexOnly = function(src, valueBlock) {
    /** @type {string} */ var decl = '';
    /** @type {string} */ var setup = '';
    /** @type {string} */ var output = '';
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';

    // Output (write out position).
    output += 'gl_Position = dEQP_Position;\n';

    // Declarations (position + attribute for each input, varying for each output).
    decl += vtxIn + ' highp vec4 dEQP_Position;\n';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var valueName = val.valueName;
    /** @type {string} */ var type = gluShaderUtil.getDataTypeName(val.dataType);

        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float') {
                decl += vtxIn + ' ' + type + ' ' + valueName + ';\n';
            } else {
                /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);

                decl += vtxIn + ' ' + floatType + ' a_' + valueName + ';\n';
                setup += type + ' ' + valueName + ' = ' + type + '(a_' + valueName + ');\n';
            }
        } else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM &&
                    !val.valueName.match('\\.'))
            decl += 'uniform ' + type + ' ' + valueName + ';\n';
    }

    /** @type {string} */
    var baseSrc = src
                    .replace(/\$\{VERTEX_DECLARATIONS\}/g, decl)
                    .replace(/\$\{VERTEX_DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
                    .replace(/\$\{VERTEX_SETUP\}/g, setup)
                    .replace(/\$\{VERTEX_OUTPUT\}/g, output);

    /** @type {string} */
    var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.VERTEX, state.currentTest.spec.requirements);

    return withExt;
};

/** Specialize a shader for the fragment shader test case.
 * @param {string} src
 * @param { {values:Array}} valueBlock
 * @return {string} withExt
 */
glsShaderLibraryCase.specializeFragmentShader = function(src, valueBlock) {
    /** @type {string} */ var decl = '';
    /** @type {string} */ var setup = '';
    /** @type {string} */ var output = '';

    /** @type {Object} */ var state = tcuTestCase.runner;

    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {boolean} */ var customColorOut = usesInout;
    /** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
    /** @type {string} */ var fragColor = customColorOut ? 'dEQP_FragColor' : 'gl_FragColor';

    decl += glsShaderLibraryCase.genCompareFunctions(valueBlock, false);
    output += glsShaderLibraryCase.genCompareOp(fragColor, valueBlock, '', null);

    if (customColorOut)
        decl += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var valueName = val.valueName;
    /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
    /** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);

        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
            if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
                decl += fragIn + ' ' + floatType + ' ' + valueName + ';\n';
            else {
                decl += fragIn + ' ' + floatType + ' v_' + valueName + ';\n';
                var offset = gluShaderUtil.isDataTypeIntOrIVec(val.dataType) ? ' * 1.0025' : ''; // \todo [petri] bit of a hack to avoid errors in chop() due to varying interpolation
                setup += refType + ' ' + valueName + ' = ' + refType + '(v_' + valueName + offset + ');\n';
            }
        } else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
            decl += 'uniform ' + refType + ' ref_' + valueName + ';\n';
            decl += refType + ' ' + valueName + ';\n';
        }
    }

    /* \todo [2010-04-01 petri] Check all outputs. */

    /** @type {string} */
    var baseSrc = src
                    .replace(/\$\{DECLARATIONS\}/g, decl)
                    .replace(/\$\{DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
                    .replace(/\$\{SETUP\}/g, setup)
                    .replace(/\$\{OUTPUT\}/g, output)
                    .replace(/\$\{POSITION_FRAG_COLOR\}/g, fragColor);

    /** @type {string} */
    var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.FRAGMENT, state.currentTest.spec.requirements);

    return withExt;
};

/** Specialize a shader only for the fragment test case.
 * @param {string} src
 * @param { {values:Array}} valueBlock
 * @return {string} withExt
 */
glsShaderLibraryCase.specializeFragmentOnly = function(src, valueBlock) {
    /** @type {string} */ var decl = '';
    /** @type {string} */ var output = '';
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
    /** @type {boolean} */ var customColorOut = usesInout;
    /** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
    /** @type {string} */ var fragColor = customColorOut ? 'dEQP_FragColor' : 'gl_FragColor';

    decl += glsShaderLibraryCase.genCompareFunctions(valueBlock, false);
    output += glsShaderLibraryCase.genCompareOp(fragColor, valueBlock, '', null);

    if (customColorOut)
        decl += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';

    for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
    /** @type {Array} */ var val = valueBlock.values[ndx];
    /** @type {string} */ var valueName = val.valueName;
    /** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
    /** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);

        if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
            decl += 'uniform ' + refType + ' ref_' + valueName + ';\n';
            decl += refType + ' ' + valueName + ';\n';
        } else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM &&
                   !valueName.match('\\.'))
            decl += 'uniform ' + refType + ' ' + valueName + ';\n';
    }

    /** @type {string} */
    var baseSrc = src
                     .replace(/\$\{FRAGMENT_DECLARATIONS\}/g, decl)
                     .replace(/\$\{FRAGMENT_DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
                     .replace(/\$\{FRAGMENT_OUTPUT\}/g, output)
                     .replace(/\$\{FRAG_COLOR\}/g, fragColor);

    /** @type {string} */
    var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.FRAGMENT, state.currentTest.spec.requirements);

    return withExt;
};

/**
 * Is tessellation present
 * @return {boolean} True if tessellation is present
 */
glsShaderLibraryCase.isTessellationPresent = function() {
    /* TODO: GLES 3.1: implement */
    return false;
};

glsShaderLibraryCase.setUniformValue = function(gl, pipelinePrograms, name, val, arrayNdx) {
    /** @type {boolean} */ var foundAnyMatch = false;

    for (var programNdx = 0; programNdx < pipelinePrograms.length; ++programNdx) {
        /** @const @type {WebGLUniformLocation} */ var loc = gl.getUniformLocation(pipelinePrograms[programNdx], name);
        /** @const @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(val.dataType);
        /** @const @type {number} */ var elemNdx = (val.arrayLength === 1) ? (0) : (arrayNdx * scalarSize);

        if (!loc)
            continue;

        foundAnyMatch = true;

        gl.useProgram(pipelinePrograms[programNdx]);

        /** @type {Array} */ var element = val.elements.slice(elemNdx, elemNdx + scalarSize);
        switch (val.dataType) {
            case gluShaderUtil.DataType.FLOAT: gl.uniform1fv(loc, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_VEC2: gl.uniform2fv(loc, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_VEC3: gl.uniform3fv(loc, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_VEC4: gl.uniform4fv(loc, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT2: gl.uniformMatrix2fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT3: gl.uniformMatrix3fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT4: gl.uniformMatrix4fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.INT: gl.uniform1iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.INT_VEC2: gl.uniform2iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.INT_VEC3: gl.uniform3iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.INT_VEC4: gl.uniform4iv(loc, new Int32Array(element)); break;

            /** TODO: What type should be used for bool uniforms? */
            case gluShaderUtil.DataType.BOOL: gl.uniform1iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.BOOL_VEC2: gl.uniform2iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.BOOL_VEC3: gl.uniform3iv(loc, new Int32Array(element)); break;
            case gluShaderUtil.DataType.BOOL_VEC4: gl.uniform4iv(loc, new Int32Array(element)); break;

            case gluShaderUtil.DataType.UINT: gl.uniform1uiv(loc, new Uint32Array(element)); break;
            case gluShaderUtil.DataType.UINT_VEC2: gl.uniform2uiv(loc, new Uint32Array(element)); break;
            case gluShaderUtil.DataType.UINT_VEC3: gl.uniform3uiv(loc, new Uint32Array(element)); break;
            case gluShaderUtil.DataType.UINT_VEC4: gl.uniform4uiv(loc, new Uint32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT2X3: gl.uniformMatrix2x3fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT2X4: gl.uniformMatrix2x4fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT3X2: gl.uniformMatrix3x2fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT3X4: gl.uniformMatrix3x4fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT4X2: gl.uniformMatrix4x2fv(loc, false, new Float32Array(element)); break;
            case gluShaderUtil.DataType.FLOAT_MAT4X3: gl.uniformMatrix4x3fv(loc, false, new Float32Array(element)); break;

            default:
                testFailed('Unknown data type ' + val.dataType);
        }
    }

    if (!foundAnyMatch)
        bufferedLogToConsole('WARNING // Uniform \"' + name + '\" location is not valid, location = -1. Cannot set value to the uniform.');
};

/**
 * Evaluates pixels, if they are white, black or there is any unexpected result
 * @param {gluDrawUtil.Surface} surface
 * @param {number} minX
 * @param {number} maxX
 * @param {number} minY
 * @param {number} maxY
 * @return {boolean} True if tessellation is present
 */
glsShaderLibraryCase.checkPixels = function(surface, minX, maxX, minY, maxY) {
    /** @type {boolean} */ var allWhite = true;
    /** @type {boolean} */ var allBlack = true;
    /** @type {boolean} */ var anyUnexpected = false;

    assertMsgOptions((maxX > minX) && (maxY > minY), 'glsShaderLibraryCase.checkPixels sanity check', false, true);

    for (var y = minY; y <= maxY; y++) {
        for (var x = minX; x <= maxX; x++) {
            /** @type {number} */ var pixel = surface.getPixelUintRGB8(x, y);
            /** @type {boolean} */ var isWhite = (pixel == 0xFFFFFF);
            /** @type {boolean} */ var isBlack = (pixel == 0x000000);

            allWhite = allWhite && isWhite;
            allBlack = allBlack && isBlack;
            anyUnexpected = anyUnexpected || (!isWhite && !isBlack);

            // Early terminate as soon as we know the check hasn't passed
            if (!allWhite && !allBlack)
                break;
        }
    }

    if (!allWhite) {
        if (anyUnexpected)
            testFailed('WARNING: expecting all rendered pixels to be white or black, but got other colors as well!');
        else if (!allBlack)
            testFailed('WARNING: got inconsistent results over the image, when all pixels should be the same color!');

        return false;
    }
    return true;
};

/**
 * Initialize a test case
 */
glsShaderLibraryCase.init = function() {
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {Object} */ var test = state.currentTest;

    bufferedLogToConsole('Processing ' + test.fullName());

    if (!test.spec.valueBlockList.length)
        test.spec.valueBlockList.push(glsShaderLibraryCase.genValueBlock());
    /** @type { {values:Array}} */ var valueBlock = test.spec.valueBlockList[0];

    if (test.spec.requirements)
        for (var ndx = 0; ndx < test.spec.requirements.length; ++ndx)
            test.spec.requirements[ndx].checkRequirements();

    /** @type {Array<gluShaderProgram.ShaderInfo>} */ var sources = [];

    if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_COMPLETE) {
    /** @type {string} */ var vertex = glsShaderLibraryCase.specializeVertexOnly(test.spec.vertexSource, valueBlock);
    /** @type {string} */ var fragment = glsShaderLibraryCase.specializeFragmentOnly(test.spec.fragmentSource, valueBlock);
        sources.push(gluShaderProgram.genVertexSource(vertex));
        sources.push(gluShaderProgram.genFragmentSource(fragment));
    } else if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_VERTEX_ONLY) {
        sources.push(gluShaderProgram.genVertexSource(glsShaderLibraryCase.specializeVertexShader(test.spec.vertexSource, valueBlock)));
        sources.push(gluShaderProgram.genFragmentSource(glsShaderLibraryCase.genFragmentShader(valueBlock)));
    } else if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_FRAGMENT_ONLY) {
        sources.push(gluShaderProgram.genVertexSource(glsShaderLibraryCase.genVertexShader(valueBlock)));
        sources.push(gluShaderProgram.genFragmentSource(glsShaderLibraryCase.specializeFragmentShader(test.spec.fragmentSource, valueBlock)));
    }

    test.programs = [];
    test.programs.push({
            programSources: {
                sources: sources
            }
        }
    );

};

/**
 * Execute a test case
 * @return {boolean} True if test case passed
 */
glsShaderLibraryCase.execute = function() {
    /** @const @type {number} */ var quadSize = 1.0;
    /** @const @type {Array<number>} */
    var s_positions = [
        -quadSize, -quadSize, 0.0, 1.0,
        -quadSize, +quadSize, 0.0, 1.0,
        +quadSize, -quadSize, 0.0, 1.0,
        +quadSize, +quadSize, 0.0, 1.0
    ];

    /** @const @type {Array<number>} */
    var s_indices = [
        0, 1, 2,
        1, 3, 2
    ];

    var wtu = WebGLTestUtils;
    /** @type {WebGL2RenderingContext} */ var gl = wtu.create3DContext('canvas');
    /** @type {Object} */ var state = tcuTestCase.runner;
    /** @type {Object} */ var test = state.currentTest;
    /** @type {Object} */ var spec = test.spec;

    // Compute viewport.
    /* TODO: original code used random number generator to compute viewport, we use whole canvas */
    /** @const @type {number} */ var width = Math.min(canvas.width, glsShaderLibraryCase.VIEWPORT_WIDTH);
    /** @const @type {number} */ var height = Math.min(canvas.height, glsShaderLibraryCase.VIEWPORT_HEIGHT);
    /** @const @type {number} */ var viewportX = 0;
    /** @const @type {number} */ var viewportY = 0;
    /** @const @type {number} */ var numVerticesPerDraw = 4;
    /** @const @type {boolean} */ var tessellationPresent = glsShaderLibraryCase.isTessellationPresent();

    /** @type {boolean} */ var allCompilesOk = true;
    /** @type {boolean} */ var allLinksOk = true;
    /** @type {?string} */ var failReason = null;

    /** @type {number} */ var vertexProgramID = -1;
    /** @type {Array<WebGLProgram>} */ var pipelineProgramIDs = [];
    /** @type {Array<gluShaderProgram.ShaderProgram>} */ var programs = [];
    var programPipeline;

    // Set the name of the current test so testFailedOptions/testPassedOptions can use it.
    setCurrentTestName(test.fullName());
    debug('Start testcase: ' + test.fullName());
    assertMsgOptions(gl.getError() === gl.NO_ERROR, 'Start testcase: ' + test.fullName(), false, true);

    /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, test.programs[0].programSources);

    vertexProgramID = program.getProgram();
    pipelineProgramIDs.push(program.getProgram());
    programs.push(program);

    // Check that compile/link results are what we expect.

    for (var i = 0; i < program.shaders.length; i++) {
        if (!program.shaders[i].info.compileOk)
            allCompilesOk = false;
    }

    if (!program.getProgramInfo().linkOk)
        allLinksOk = false;

    switch (spec.expectResult) {
        case glsShaderLibraryCase.expectResult.EXPECT_PASS:
        case glsShaderLibraryCase.expectResult.EXPECT_VALIDATION_FAIL:
        case glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL:
            if (!allCompilesOk)
                failReason = 'expected shaders to compile and link properly, but failed to compile.';
            else if (!allLinksOk)
                failReason = 'expected shaders to compile and link properly, but failed to link.';
            break;

        case glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL:
            if (allCompilesOk && !allLinksOk)
                failReason = 'expected compilation to fail, but shaders compiled and link failed.';
            else if (allCompilesOk)
                failReason = 'expected compilation to fail, but shaders compiled correctly.';
            break;

        case glsShaderLibraryCase.expectResult.EXPECT_LINK_FAIL:
            if (!allCompilesOk)
                failReason = 'expected linking to fail, but unable to compile.';
            else if (allLinksOk)
                failReason = 'expected linking to fail, but passed.';
            break;

        case glsShaderLibraryCase.expectResult.EXPECT_COMPILE_LINK_FAIL:
            if (allCompilesOk && allLinksOk)
                failReason = 'expected compile or link to fail, but passed.';
            break;

        default:
            testFailedOptions('Unknown expected result', true);
            return false;
    }

    if (failReason != null) {
        // \todo [2010-06-07 petri] These should be handled in the test case?

        // If implementation parses shader at link time, report it as quality warning.
        if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL && allCompilesOk && !allLinksOk)
            bufferedLogToConsole('Quality warning: implementation parses shader at link time: ' + failReason);
        else {
            bufferedLogToConsole('ERROR: ' + failReason);
            testFailedOptions(failReason, true);
        }
        return false;
    }

    // Return if compile/link expected to fail.
    if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL ||
        spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_LINK_FAIL ||
        spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_LINK_FAIL ||
        spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL) {
        if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL) {
            testPassedOptions('Compile/link is expected to succeed', true);
        } else {
            testPassedOptions('Compile/link is expected to fail', true);
        }
        setCurrentTestName('');
        return (failReason === null);
    }

    // Setup viewport.
    gl.viewport(viewportX, viewportY, width, height);

    // Start using program
    gl.useProgram(vertexProgramID);
    assertMsgOptions(gl.getError() === gl.NO_ERROR, 'glUseProgram()', false, true);

    // Fetch location for positions positions.
    /** @type {number} */ var positionLoc = gl.getAttribLocation(vertexProgramID, 'dEQP_Position');
    if (positionLoc === -1) {
        testFailedOptions("no location found for attribute 'dEQP_Position'", true);
        return false;
    }

    // Iterate all value blocks.
    for (var blockNdx = 0; blockNdx < spec.valueBlockList.length; blockNdx++) {
    /** @type { {values:Array}} */ var block = spec.valueBlockList[blockNdx];

        // always render at least one pass even if there is no input/output data
        /** @const @type {number} */ var numRenderPasses = Math.max(block.arrayLength, 1);

        // Iterate all array sub-cases.
        for (var arrayNdx = 0; arrayNdx < numRenderPasses; arrayNdx++) {
            /** @const @type {number} */ var numValues = block.values.length;
            /** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [];
            /** @type {number} */ var attribValueNdx = 0;
            /** @type {number} */ var postDrawError;

            vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, positionLoc, 4, numVerticesPerDraw, s_positions));

            // Collect VA pointer for inputs
            for (var valNdx = 0; valNdx < numValues; valNdx++) {
                var val = block.values[valNdx];
                /** @const @type {string} */ var valueName = val.valueName;
                /** @const @type {gluShaderUtil.DataType} */ var dataType = val.dataType;
                /** @const @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(val.dataType);

                if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
                    // Replicate values four times.
                /** @type {Array} */ var scalars = [];

                    for (var repNdx = 0; repNdx < numVerticesPerDraw; repNdx++)
                        for (var ndx = 0; ndx < scalarSize; ndx++)
                            scalars[repNdx * scalarSize + ndx] = val.elements[arrayNdx * scalarSize + ndx];

                    // Attribute name prefix.
                    /** @type {string} */ var attribPrefix = '';
                    // \todo [2010-05-27 petri] Should latter condition only apply for vertex cases (or actually non-fragment cases)?
                    if ((spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_FRAGMENT_ONLY) || (gluShaderUtil.getDataTypeScalarType(dataType) !== 'float'))
                        attribPrefix = 'a_';

                    // Input always given as attribute.
                    /** @type {string} */ var attribName = attribPrefix + valueName;
                    /** @type {number} */ var attribLoc = gl.getAttribLocation(vertexProgramID, attribName);
                    if (attribLoc === -1) {
                        bufferedLogToConsole("Warning: no location found for attribute '" + attribName + "'");
                        continue;
                    }

                    if (gluShaderUtil.isDataTypeMatrix(dataType)) {
                        var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(dataType);
                        var numRows = gluShaderUtil.getDataTypeMatrixNumRows(dataType);

                        assertMsgOptions(scalarSize === numCols * numRows, 'Matrix size sanity check', false, true);

                        for (var i = 0; i < numCols; i++)
                            vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, attribLoc + i, numRows, numVerticesPerDraw, scalars, scalarSize * 4, i * numRows * 4));
                    } else
                            vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, attribLoc, scalarSize, numVerticesPerDraw, scalars));

                    assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set vertex attrib array', false, true);
                }
            }

            assertMsgOptions(gl.getError() === gl.NO_ERROR, 'before set uniforms', false, true);

            // set uniform values for outputs (refs).
            for (var valNdx = 0; valNdx < numValues; valNdx++) {
            /** @type {Array} */ var val1 = block.values[valNdx];
            /** @type {string} */ var valueName1 = val1.valueName;

                if (val1.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
                    // Set reference value.
                    glsShaderLibraryCase.setUniformValue(gl, pipelineProgramIDs, 'ref_' + valueName1, val1, arrayNdx);
                    assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set reference uniforms', false, true);
                } else if (val1.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM) {
                    glsShaderLibraryCase.setUniformValue(gl, pipelineProgramIDs, valueName1, val1, arrayNdx);
                    assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set uniforms', false, true);
                }
            }

            // Clear.
            gl.clearColor(0.125, 0.25, 0.5, 1);
            gl.clear(gl.COLOR_BUFFER_BIT);
            assertMsgOptions(gl.getError() === gl.NO_ERROR, 'clear buffer', false, true);

            // Use program or pipeline
            if (spec.separatePrograms)
                gl.useProgram(null);
            else
                gl.useProgram(vertexProgramID);

            // Draw.
            // if (tessellationPresent) {
            //     gl.patchParameteri(gl.PATCH_VERTICES, 3);
            //     assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set patchParameteri(PATCH_VERTICES, 3)', false, true);
            // }

            gluDrawUtil.draw(gl, vertexProgramID, vertexArrays, gluDrawUtil.triangles(s_indices));

            postDrawError = gl.getError();

            if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_PASS) {
                /** @type {gluDrawUtil.Surface} */ var surface = new gluDrawUtil.Surface();
                /** @const @type {number} */ var w = s_positions[3];
                /** @const @type {number} */ var minY = Math.ceil(((-quadSize / w) * 0.5 + 0.5) * height + 1.0);
                /** @const @type {number} */ var maxY = Math.floor(((+quadSize / w) * 0.5 + 0.5) * height - 0.5);
                /** @const @type {number} */ var minX = Math.ceil(((-quadSize / w) * 0.5 + 0.5) * width + 1.0);
                /** @const @type {number} */ var maxX = Math.floor(((+quadSize / w) * 0.5 + 0.5) * width - 0.5);

                assertMsgOptions(postDrawError === gl.NO_ERROR, 'draw', false, true);

                surface.readSurface(gl, viewportX, viewportY, width, height);
                assertMsgOptions(gl.getError() === gl.NO_ERROR, 'read pixels', false, true);

                if (!glsShaderLibraryCase.checkPixels(surface, minX, maxX, minY, maxY)) {
                    testFailedOptions((
                        'INCORRECT RESULT for (value block ' + (blockNdx + 1) +
                        ' of ' + spec.valueBlockList.length + ', sub-case ' +
                        (arrayNdx + 1) + ' of ' + block.arrayLength + '):'
                    ), true);

                    /* TODO: Port */
                    /*
                    log << TestLog::Message << "Failing shader input/output values:" << TestLog::EndMessage;
                    dumpValues(block, arrayNdx);

                    // Dump image on failure.
                    log << TestLog::Image("Result", "Rendered result image", surface);

                    */
                    gl.useProgram(null);

                    return false;
                }
            } else if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_VALIDATION_FAIL) {
                /** TODO: GLES 3.1: Implement */
                testFailedOptions('Unsupported test case', true);
            }
        }
    }
    gl.useProgram(null);

    assertMsgOptions(gl.getError() === gl.NO_ERROR, '', true, true);
    setCurrentTestName('');

    return true;
};

glsShaderLibraryCase.runTestCases = function() {
/** @type {Object} */ var state = tcuTestCase.runner;
    if (state.next()) {
        try {
            glsShaderLibraryCase.init();
            glsShaderLibraryCase.execute();
        } catch (err) {
           bufferedLogToConsole(err);
        }
        tcuTestCase.runner.runCallback(glsShaderLibraryCase.runTestCases);
    } else
    tcuTestCase.runner.terminate();

};

glsShaderLibraryCase.genValueBlock = function() {
    return {
    /** @type {Array} */ values: [],
    /** @type {number} */ arrayLength: 0
    };
};

});