/*-------------------------------------------------------------------------
 * 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.glsUniformBlockCase');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.delibs.debase.deUtil');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');

goog.scope(function() {

var glsUniformBlockCase = modules.shared.glsUniformBlockCase;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var deUtil = framework.delibs.debase.deUtil;
var deMath = framework.delibs.debase.deMath;
var deRandom = framework.delibs.debase.deRandom;
var deString = framework.delibs.debase.deString;

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

var littleEndian = (function() {
    var buffer = new ArrayBuffer(2);
    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
    // Int16Array uses the platform's endianness.
    return new Int16Array(buffer)[0] === 256;
})();

/**
 * Class to implement some pointers functionality.
 * @constructor
 */
glsUniformBlockCase.BlockPointers = function() {
    /** @type {ArrayBuffer} */ this.data; //!< Data (vector<deUint8>).
    /** @type {Array<number>} */ this.offsets = []; //!< Reference block pointers (map<int, void*>).
    /** @type {Array<number>} */ this.sizes = [];
};

/**
 * push - Adds an offset/size pair to the collection
 * @param {number} offset Offset of the element to refer.
 * @param {number} size Size of the referred element.
 */
glsUniformBlockCase.BlockPointers.prototype.push = function(offset, size) {
    this.offsets.push(offset);
    this.sizes.push(size);
};

/**
 * find - Finds and maps the data at the given offset, and returns a Uint8Array
 * @param {number} index of the element to find.
 * @return {Uint8Array}
 */
glsUniformBlockCase.BlockPointers.prototype.find = function(index) {
    return new Uint8Array(this.data, this.offsets[index], this.sizes[index]);
};

/**
 * resize - Replaces resize of a vector in C++. Sets the size of the data buffer.
 * NOTE: In this case however, if you resize, the data is lost.
 * @param {number} newsize The new size of the data buffer.
 */
glsUniformBlockCase.BlockPointers.prototype.resize = function(newsize) {
    this.data = new ArrayBuffer(newsize);
};

/**
 * glsUniformBlockCase.isSupportedGLSLVersion
 * @param {gluShaderUtil.GLSLVersion} version
 * @return {boolean}
 */
glsUniformBlockCase.isSupportedGLSLVersion = function(version) {
    return version >= gluShaderUtil.GLSLVersion.V300_ES;
};

/**
 * @enum {number}
 */
glsUniformBlockCase.UniformFlags = {
    PRECISION_LOW: (1 << 0),
    PRECISION_MEDIUM: (1 << 1),
    PRECISION_HIGH: (1 << 2),

    LAYOUT_SHARED: (1 << 3),
    LAYOUT_PACKED: (1 << 4),
    LAYOUT_STD140: (1 << 5),
    LAYOUT_ROW_MAJOR: (1 << 6),
    LAYOUT_COLUMN_MAJOR: (1 << 7), //!< \note Lack of both flags means column-major matrix.

    DECLARE_VERTEX: (1 << 8),
    DECLARE_FRAGMENT: (1 << 9),

    UNUSED_VERTEX: (1 << 10), //!< glsUniformBlockCase.Uniform or struct member is not read in vertex shader.
    UNUSED_FRAGMENT: (1 << 11) //!< glsUniformBlockCase.Uniform or struct member is not read in fragment shader.
};

/** @const */ glsUniformBlockCase.UniformFlags.PRECISION_MASK = glsUniformBlockCase.UniformFlags.PRECISION_LOW | glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM | glsUniformBlockCase.UniformFlags.PRECISION_HIGH;
/** @const */ glsUniformBlockCase.UniformFlags.LAYOUT_MASK = glsUniformBlockCase.UniformFlags.LAYOUT_SHARED | glsUniformBlockCase.UniformFlags.LAYOUT_PACKED | glsUniformBlockCase.UniformFlags.LAYOUT_STD140 | glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR | glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR;
/** @const */ glsUniformBlockCase.UniformFlags.DECLARE_BOTH = glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT;
/** @const */ glsUniformBlockCase.UniformFlags.UNUSED_BOTH = glsUniformBlockCase.UniformFlags.UNUSED_VERTEX | glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT;

/**
* glsUniformBlockCase.VarType types enum
* @enum {number}
*/
glsUniformBlockCase.Type = {
    TYPE_BASIC: 0,
    TYPE_ARRAY: 1,
    TYPE_STRUCT: 2
};

glsUniformBlockCase.Type.TYPE_LAST = Object.keys(glsUniformBlockCase.Type).length;

/**
* glsUniformBlockCase.TypeArray struct (nothing to do with JS's TypedArrays)
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @constructor
*/
glsUniformBlockCase.TypeArray = function(elementType, arraySize) {
    /** @type {glsUniformBlockCase.VarType} */ this.elementType = elementType;
    /** @type {number} */ this.size = arraySize;
};

/**
 * glsUniformBlockCase.VarType class
 * @constructor
 */
glsUniformBlockCase.VarType = function() {
    /** @type {glsUniformBlockCase.Type} */ this.m_type;
    /** @type {number} */ this.m_flags = 0;

    /*
     * m_data used to be a 'Data' union in C++. Using a var is enough here.
     * it will contain any necessary value.
     */

    /** @type {(gluShaderUtil.DataType|glsUniformBlockCase.TypeArray|glsUniformBlockCase.StructType)} */
    this.m_data;
};

/**
* Creates a basic type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {gluShaderUtil.DataType} basicType
* @param {number} flags
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeBasic = function(basicType, flags) {
    this.m_type = glsUniformBlockCase.Type.TYPE_BASIC;
    this.m_flags = flags;
    this.m_data = basicType;

    return this;
};

/**
* Creates an array type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeArray = function(elementType, arraySize) {
    this.m_type = glsUniformBlockCase.Type.TYPE_ARRAY;
    this.m_flags = 0;
    this.m_data = new glsUniformBlockCase.TypeArray(elementType, arraySize);

    return this;
};

/**
* Creates a struct type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {glsUniformBlockCase.StructType} structPtr
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeStruct = function(structPtr) {
    this.m_type = glsUniformBlockCase.Type.TYPE_STRUCT;
    this.m_flags = 0;
    this.m_data = structPtr;

    return this;
};

/** isBasicType
* @return {boolean} true if the glsUniformBlockCase.VarType represents a basic type.
**/
glsUniformBlockCase.VarType.prototype.isBasicType = function() {
    return this.m_type == glsUniformBlockCase.Type.TYPE_BASIC;
};

/** isArrayType
* @return {boolean} true if the glsUniformBlockCase.VarType represents an array.
**/
glsUniformBlockCase.VarType.prototype.isArrayType = function() {
    return this.m_type == glsUniformBlockCase.Type.TYPE_ARRAY;
};

/** isStructType
* @return {boolean} true if the glsUniformBlockCase.VarType represents a struct.
**/
glsUniformBlockCase.VarType.prototype.isStructType = function() {
    return this.m_type == glsUniformBlockCase.Type.TYPE_STRUCT;
};

/** getFlags
* @return {number} returns the flags of the glsUniformBlockCase.VarType.
**/
glsUniformBlockCase.VarType.prototype.getFlags = function() {
    return this.m_flags;
};

/** getBasicType
* @return {gluShaderUtil.DataType} returns the basic data type of the glsUniformBlockCase.VarType.
**/
glsUniformBlockCase.VarType.prototype.getBasicType = function() {
    return /** @type {gluShaderUtil.DataType} */ (this.m_data);
};

/** getElementType
* @return {glsUniformBlockCase.VarType} returns the glsUniformBlockCase.VarType of the element in case of an Array.
**/
glsUniformBlockCase.VarType.prototype.getElementType = function() {
    return this.m_data.elementType;
};

/** getArraySize
* (not to be confused with a javascript array)
* @return {number} returns the size of the array in case it is an array.
**/
glsUniformBlockCase.VarType.prototype.getArraySize = function() {
    return this.m_data.size;
};

/** getStruct
* @return {glsUniformBlockCase.StructType} returns the structure when it is a glsUniformBlockCase.StructType.
**/
glsUniformBlockCase.VarType.prototype.getStruct = function() {
    return /** @type {glsUniformBlockCase.StructType} */ (this.m_data);
};

/**
 * Creates a basic type glsUniformBlockCase.VarType.
 * @param {gluShaderUtil.DataType} basicType
 * @param {number} flags
 * @return {glsUniformBlockCase.VarType}
 */
glsUniformBlockCase.newVarTypeBasic = function(basicType, flags) {
    return new glsUniformBlockCase.VarType().VarTypeBasic(basicType, flags);
};

/**
* Creates an array type glsUniformBlockCase.VarType.
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.newVarTypeArray = function(elementType, arraySize) {
    return new glsUniformBlockCase.VarType().VarTypeArray(elementType, arraySize);
};

/**
* Creates a struct type glsUniformBlockCase.VarType.
* @param {glsUniformBlockCase.StructType} structPtr
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.newVarTypeStruct = function(structPtr) {
    return new glsUniformBlockCase.VarType().VarTypeStruct(structPtr);
};

/** glsUniformBlockCase.StructMember
 * in the JSDoc annotations or if a number would do.
 * @constructor
**/
glsUniformBlockCase.StructMember = function() {
    /** @type {string} */ this.m_name;
    /** @type {glsUniformBlockCase.VarType} */ this.m_type;
    /** @type {number} */ this.m_flags = 0;
};

/**
 * Creates a glsUniformBlockCase.StructMember. Use this after the constructor call.
 * @param {string} name
 * @param {glsUniformBlockCase.VarType} type
 * @param {number} flags
 * @return {glsUniformBlockCase.StructMember} The currently modified object
 */
glsUniformBlockCase.StructMember.prototype.Constructor = function(name, type, flags) {
    this.m_type = type;
    this.m_name = name;
    this.m_flags = flags;

    return this;
};

/** getName
* @return {string} the name of the member
**/
glsUniformBlockCase.StructMember.prototype.getName = function() { return this.m_name; };

/** getType
* @return {glsUniformBlockCase.VarType} the type of the member
**/
glsUniformBlockCase.StructMember.prototype.getType = function() { return this.m_type; };

/** getFlags
* @return {number} the flags in the member
**/
glsUniformBlockCase.StructMember.prototype.getFlags = function() { return this.m_flags; };

/**
 * Creates a glsUniformBlockCase.StructMember with name, type and flags.
 * @param {string} name
 * @param {glsUniformBlockCase.VarType} type
 * @return {glsUniformBlockCase.StructMember}
 */
 glsUniformBlockCase.newStructMember = function(name, type, flags) {
     return new glsUniformBlockCase.StructMember().Constructor(name, type, flags);
 };

/**
 * glsUniformBlockCase.StructType
 * @constructor
 */
glsUniformBlockCase.StructType = function() {
    /** @type {string}*/ this.m_typeName;
    /** @type {Array<glsUniformBlockCase.StructMember>} */ this.m_members = [];
};

/**
 * glsUniformBlockCase.StructType - Constructor with type name
 * @param {string} typeName
 * @return {glsUniformBlockCase.StructType} The currently modified object.
 */
glsUniformBlockCase.StructType.prototype.Constructor = function(typeName) {
    /** @type {string}*/ this.m_typeName = typeName;
    return this;
};

/** getTypeName
* @return {string}
**/
glsUniformBlockCase.StructType.prototype.getTypeName = function() {
    return this.m_typeName;
};

/*
 * Instead of iterators, we'll add
 * a getter for a specific element (getMember),
 * and current members amount (getSize).
 */

/** getMember
* @param {number} memberNdx The index of the member to retrieve.
* @return {glsUniformBlockCase.StructMember}
**/
glsUniformBlockCase.StructType.prototype.getMember = function(memberNdx) {
    if (memberNdx >= 0 && memberNdx < this.m_members.length)
        return this.m_members[memberNdx];
    else {
        throw new Error("Invalid member index for glsUniformBlockCase.StructType's members");
    }
};

/** getSize
* @return {number} The size of the m_members array.
**/
glsUniformBlockCase.StructType.prototype.getSize = function() {
    return this.m_members.length;
};

/** addMember
* @param {string} member_name
* @param {glsUniformBlockCase.VarType} member_type
* @param {number=} member_flags
**/
glsUniformBlockCase.StructType.prototype.addMember = function(member_name, member_type, member_flags) {
    var member = glsUniformBlockCase.newStructMember(member_name, member_type, member_flags);

    this.m_members.push(member);
};

/**
 * Creates a glsUniformBlockCase.StructType.
 * @param {string} name
 * @return {glsUniformBlockCase.StructType}
 */
glsUniformBlockCase.newStructType = function(name) {
    return new glsUniformBlockCase.StructType().Constructor(name);
};

/** glsUniformBlockCase.Uniform
 * @param {string} name
 * @param {glsUniformBlockCase.VarType} type
 * @param {number=} flags
 * @constructor
**/
glsUniformBlockCase.Uniform = function(name, type, flags) {
    /** @type {string} */ this.m_name = name;
    /** @type {glsUniformBlockCase.VarType} */ this.m_type = type;
    /** @type {number} */ this.m_flags = (typeof flags === 'undefined') ? 0 : flags;
};

/** getName
 * @return {string}
 */
glsUniformBlockCase.Uniform.prototype.getName = function() {
    return this.m_name;
};

/** getType
 * @return {glsUniformBlockCase.VarType}
 */
glsUniformBlockCase.Uniform.prototype.getType = function() {
    return this.m_type;
};

/** getFlags
* @return {number}
**/
glsUniformBlockCase.Uniform.prototype.getFlags = function() {
    return this.m_flags;
};

/** glsUniformBlockCase.UniformBlock
 * @param {string} blockName
 * @constructor
**/
glsUniformBlockCase.UniformBlock = function(blockName) {
    /** @type {string} */ this.m_blockName = blockName;
    /** @type {string} */ this.m_instanceName;
    /** @type {Array<glsUniformBlockCase.Uniform>} */ this.m_uniforms = [];
    /** @type {number} */ this.m_arraySize = 0; //!< Array size or 0 if not interface block array.
    /** @type {number} */ this.m_flags = 0;
};

/** getBlockName
* @return {string}
**/
glsUniformBlockCase.UniformBlock.prototype.getBlockName = function() {
    return this.m_blockName;
};

/** getInstanceName
* @return {string}
**/
glsUniformBlockCase.UniformBlock.prototype.getInstanceName = function() {
    return this.m_instanceName;
};

/** isArray
* @return {boolean}
**/
glsUniformBlockCase.UniformBlock.prototype.isArray = function() {
    return this.m_arraySize > 0;
};

/** getArraySize
* @return {number}
**/
glsUniformBlockCase.UniformBlock.prototype.getArraySize = function() {
    return this.m_arraySize;
};

/** getFlags
* @return {number}
**/
glsUniformBlockCase.UniformBlock.prototype.getFlags = function() {
    return this.m_flags;
};

/** setInstanceName
* @param {string} name
**/
glsUniformBlockCase.UniformBlock.prototype.setInstanceName = function(name) {
    this.m_instanceName = name;
};

/** setFlags
* @param {number} flags
**/
glsUniformBlockCase.UniformBlock.prototype.setFlags = function(flags) {
    this.m_flags = flags;
};

/** setArraySize
* @param {number} arraySize
**/
glsUniformBlockCase.UniformBlock.prototype.setArraySize = function(arraySize) {
    this.m_arraySize = arraySize;
};

/** addUniform
* @param {glsUniformBlockCase.Uniform} uniform
**/
glsUniformBlockCase.UniformBlock.prototype.addUniform = function(uniform) {
    this.m_uniforms.push(uniform);
};

/*
 * Using uniform getter (getUniform),
 * and uniform array size getter (countUniforms)
 * instead of iterators.
*/

/**
 * getUniform
 * @param {number} index
 * @return {glsUniformBlockCase.Uniform}
 */
glsUniformBlockCase.UniformBlock.prototype.getUniform = function(index) {
    if (index >= 0 && index < this.m_uniforms.length)
        return this.m_uniforms[index];
    else {
        throw new Error("Invalid uniform index for glsUniformBlockCase.UniformBlock's uniforms");
    }
};

/**
 * countUniforms
 * @return {number}
 */
glsUniformBlockCase.UniformBlock.prototype.countUniforms = function() {
    return this.m_uniforms.length;
};

/**
 * glsUniformBlockCase.ShaderInterface
 * @constructor
 */
glsUniformBlockCase.ShaderInterface = function() {
    /** @type {Array<glsUniformBlockCase.StructType>} */ this.m_structs = [];
    /** @type {Array<glsUniformBlockCase.UniformBlock>} */ this.m_uniformBlocks = [];
};

/** allocStruct
* @param {string} name
* @return {glsUniformBlockCase.StructType}
**/
glsUniformBlockCase.ShaderInterface.prototype.allocStruct = function(name) {
    //m_structs.reserve(m_structs.length + 1);
    this.m_structs.push(glsUniformBlockCase.newStructType(name));
    return this.m_structs[this.m_structs.length - 1];
};

/** findStruct
* @param {string} name
* @return {glsUniformBlockCase.StructType}
**/
glsUniformBlockCase.ShaderInterface.prototype.findStruct = function(name) {
    for (var pos = 0; pos < this.m_structs.length; pos++) {
        if (this.m_structs[pos].getTypeName() == name)
            return this.m_structs[pos];
    }
    return null;
};

/** getNamedStructs
* @param {Array<glsUniformBlockCase.StructType>} structs
**/
glsUniformBlockCase.ShaderInterface.prototype.getNamedStructs = function(structs) {
    for (var pos = 0; pos < this.m_structs.length; pos++) {
        if (this.m_structs[pos].getTypeName() != undefined)
            structs.push(this.m_structs[pos]);
    }
};

/** allocBlock
* @param {string} name
* @return {glsUniformBlockCase.UniformBlock}
**/
glsUniformBlockCase.ShaderInterface.prototype.allocBlock = function(name) {
    this.m_uniformBlocks.push(new glsUniformBlockCase.UniformBlock(name));
    return this.m_uniformBlocks[this.m_uniformBlocks.length - 1];
};

/** getNumUniformBlocks
* @return {number}
**/
glsUniformBlockCase.ShaderInterface.prototype.getNumUniformBlocks = function() {
    return this.m_uniformBlocks.length;
};

/** getUniformBlock
* @param {number} ndx
* @return {glsUniformBlockCase.UniformBlock}
**/
glsUniformBlockCase.ShaderInterface.prototype.getUniformBlock = function(ndx) {
    return this.m_uniformBlocks[ndx];
};

/**
 * @constructor
 */
glsUniformBlockCase.BlockLayoutEntry = function() {
    return {
    /** @type {number} */ size: 0,
    /** @type {string} */ name: '',
    /** @type {Array<number>} */ activeUniformIndices: []
    };
};

/**
 * @constructor
 */
glsUniformBlockCase.UniformLayoutEntry = function() {
    return {
    /** @type {string} */ name: '',
    /** @type {gluShaderUtil.DataType} */ type: gluShaderUtil.DataType.INVALID,
    /** @type {number} */ size: 0,
    /** @type {number} */ blockNdx: -1,
    /** @type {number} */ offset: -1,
    /** @type {number} */ arrayStride: -1,
    /** @type {number} */ matrixStride: -1,
    /** @type {boolean} */ isRowMajor: false
    };
};

/**
 * @constructor
 */
glsUniformBlockCase.UniformLayout = function() {
    /** @type {Array<glsUniformBlockCase.BlockLayoutEntry>}*/ this.blocks = [];
    /** @type {Array<glsUniformBlockCase.UniformLayoutEntry>}*/ this.uniforms = [];
};

/** getUniformIndex, returns a uniform index number in the layout,
 * given the uniform's name.
 * @param {string} name
 * @return {number} uniform's index
 */
glsUniformBlockCase.UniformLayout.prototype.getUniformIndex = function(name) {
    for (var ndx = 0; ndx < this.uniforms.length; ndx++) {
        if (this.uniforms[ndx].name == name)
            return ndx;
    }
    return -1;
};

/** getBlockIndex, returns a block index number in the layout,
 * given the block's name.
 * @param {string} name the name of the block
 * @return {number} block's index
 */
glsUniformBlockCase.UniformLayout.prototype.getBlockIndex = function(name) {
    for (var ndx = 0; ndx < this.blocks.length; ndx++) {
        if (this.blocks[ndx].name == name)
            return ndx;
    }
    return -1;
};

/**
 * @enum {number}
 */
glsUniformBlockCase.BufferMode = {
    BUFFERMODE_SINGLE: 0, //!< Single buffer shared between uniform blocks.
    BUFFERMODE_PER_BLOCK: 1 //!< Per-block buffers
};

glsUniformBlockCase.BufferMode.BUFFERMODE_LAST = Object.keys(glsUniformBlockCase.BufferMode).length;

/**
 * glsUniformBlockCase.PrecisionFlagsFmt
 * @param {number} flags
 * @return {string}
 */
glsUniformBlockCase.PrecisionFlagsFmt = function(flags) {
    // Precision.
    DE_ASSERT(deMath.dePop32(flags & (glsUniformBlockCase.UniformFlags.PRECISION_LOW | glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM | glsUniformBlockCase.UniformFlags.PRECISION_HIGH)) <= 1);
    var str = '';
    str += (flags & glsUniformBlockCase.UniformFlags.PRECISION_LOW ? 'lowp' :
            flags & glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM ? 'mediump' :
            flags & glsUniformBlockCase.UniformFlags.PRECISION_HIGH ? 'highp' : '');

    return str;
};

/**
 * glsUniformBlockCase.LayoutFlagsFmt
 * @param {number} flags_
 * @return {string}
 */
glsUniformBlockCase.LayoutFlagsFmt = function(flags_) {
    var str = '';
    var bitDesc =
    [{ bit: glsUniformBlockCase.UniformFlags.LAYOUT_SHARED, token: 'shared' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_PACKED, token: 'packed' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_STD140, token: 'std140' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR, token: 'row_major' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR, token: 'column_major' }
    ];

    /** @type {number} */ var remBits = flags_;
    for (var descNdx = 0; descNdx < bitDesc.length; descNdx++) {
        if (remBits & bitDesc[descNdx].bit) {
            if (remBits != flags_)
                str += ', ';
            str += bitDesc[descNdx].token;
            remBits &= (~bitDesc[descNdx].bit) & 0xFFFFFFFF; //0xFFFFFFFF truncate to 32 bit value
        }
    }
    DE_ASSERT(remBits == 0);

    return str;
};

/**
 * @constructor
 */
glsUniformBlockCase.UniformBufferManager = function(renderCtx) {
    this.m_renderCtx = renderCtx;
    /** @type {Array<number>} */ this.m_buffers = [];
};

/**
 * allocBuffer
 * @return {WebGLBuffer}
 */
glsUniformBlockCase.UniformBufferManager.prototype.allocBuffer = function() {
    /** @type {WebGLBuffer} */ var buf = this.m_renderCtx.createBuffer();

    this.m_buffers.push(buf);

    return buf;
};

/**
 * @param {string} name
 * @param {string} description
 * @param {glsUniformBlockCase.BufferMode} bufferMode
 * @constructor
 * @extends {tcuTestCase.DeqpTest}
 */
glsUniformBlockCase.UniformBlockCase = function(name, description, bufferMode) {
    tcuTestCase.DeqpTest.call(this, name, description);
    /** @type {string} */ this.m_name = name;
    /** @type {string} */ this.m_description = description;
    /** @type {glsUniformBlockCase.BufferMode} */ this.m_bufferMode = bufferMode;
    /** @type {glsUniformBlockCase.ShaderInterface} */ this.m_interface = new glsUniformBlockCase.ShaderInterface();
};

glsUniformBlockCase.UniformBlockCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
glsUniformBlockCase.UniformBlockCase.prototype.constructor = glsUniformBlockCase.UniformBlockCase;

/**
 * glsUniformBlockCase.getDataTypeByteSize
 * @param {gluShaderUtil.DataType} type
 * @return {number}
 */
glsUniformBlockCase.getDataTypeByteSize = function(type) {
    return gluShaderUtil.getDataTypeScalarSize(type) * deMath.INT32_SIZE;
};

/**
 * glsUniformBlockCase.getDataTypeByteAlignment
 * @param {gluShaderUtil.DataType} type
 * @return {number}
 */
glsUniformBlockCase.getDataTypeByteAlignment = function(type) {
    switch (type) {
        case gluShaderUtil.DataType.FLOAT:
        case gluShaderUtil.DataType.INT:
        case gluShaderUtil.DataType.UINT:
        case gluShaderUtil.DataType.BOOL: return 1 * deMath.INT32_SIZE;

        case gluShaderUtil.DataType.FLOAT_VEC2:
        case gluShaderUtil.DataType.INT_VEC2:
        case gluShaderUtil.DataType.UINT_VEC2:
        case gluShaderUtil.DataType.BOOL_VEC2: return 2 * deMath.INT32_SIZE;

        case gluShaderUtil.DataType.FLOAT_VEC3:
        case gluShaderUtil.DataType.INT_VEC3:
        case gluShaderUtil.DataType.UINT_VEC3:
        case gluShaderUtil.DataType.BOOL_VEC3: // Fall-through to vec4

        case gluShaderUtil.DataType.FLOAT_VEC4:
        case gluShaderUtil.DataType.INT_VEC4:
        case gluShaderUtil.DataType.UINT_VEC4:
        case gluShaderUtil.DataType.BOOL_VEC4: return 4 * deMath.INT32_SIZE;

        default:
            DE_ASSERT(false);
            return 0;
    }
};

/**
 * glsUniformBlockCase.getDataTypeArrayStride
 * @param {gluShaderUtil.DataType} type
 * @return {number}
 */
glsUniformBlockCase.getDataTypeArrayStride = function(type) {
    DE_ASSERT(!gluShaderUtil.isDataTypeMatrix(type));

    /** @type {number} */ var baseStride = glsUniformBlockCase.getDataTypeByteSize(type);
    /** @type {number} */ var vec4Alignment = deMath.INT32_SIZE * 4;

    DE_ASSERT(baseStride <= vec4Alignment);
    return Math.max(baseStride, vec4Alignment); // Really? See rule 4.
};

/**
 * glsUniformBlockCase.deRoundUp32 Rounds up 'a' in case the
 * relationship with 'b' has a decimal part.
 * @param {number} a
 * @param {number} b
 * @return {number}
 */
glsUniformBlockCase.deRoundUp32 = function(a, b) {
    var d = Math.trunc(a / b);
    return d * b == a ? a : (d + 1) * b;
};

/**
 * glsUniformBlockCase.computeStd140BaseAlignment
 * @param {glsUniformBlockCase.VarType} type
 * @return {number}
 */
glsUniformBlockCase.computeStd140BaseAlignment = function(type) {
    /** @type {number} */ var vec4Alignment = deMath.INT32_SIZE * 4;

    if (type.isBasicType()) {
        /** @type {gluShaderUtil.DataType} */ var basicType = type.getBasicType();

        if (gluShaderUtil.isDataTypeMatrix(basicType)) {
            /** @type {boolean} */ var isRowMajor = !!(type.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
            /** @type {number} */ var vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(basicType) :
            gluShaderUtil.getDataTypeMatrixNumRows(basicType);

            return glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));
        } else
            return glsUniformBlockCase.getDataTypeByteAlignment(basicType);
    } else if (type.isArrayType()) {
        /** @type {number} */ var elemAlignment = glsUniformBlockCase.computeStd140BaseAlignment(type.getElementType());

        // Round up to alignment of vec4
        return glsUniformBlockCase.deRoundUp32(elemAlignment, vec4Alignment);
    } else {
        DE_ASSERT(type.isStructType());

        /** @type {number} */ var maxBaseAlignment = 0;

        for (var memberNdx = 0; memberNdx < type.getStruct().getSize(); memberNdx++) {
            /** @type {glsUniformBlockCase.StructMember} */ var memberIter = type.getStruct().getMember(memberNdx);
            maxBaseAlignment = Math.max(maxBaseAlignment, glsUniformBlockCase.computeStd140BaseAlignment(memberIter.getType()));
        }

        return glsUniformBlockCase.deRoundUp32(maxBaseAlignment, vec4Alignment);
    }
};

/**
 * mergeLayoutflags
 * @param {number} prevFlags
 * @param {number} newFlags
 * @return {number}
 */
glsUniformBlockCase.mergeLayoutFlags = function(prevFlags, newFlags) {
    /** @type {number} */ var packingMask = glsUniformBlockCase.UniformFlags.LAYOUT_PACKED | glsUniformBlockCase.UniformFlags.LAYOUT_SHARED | glsUniformBlockCase.UniformFlags.LAYOUT_STD140;
    /** @type {number} */ var matrixMask = glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR | glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR;

    /** @type {number} */ var mergedFlags = 0;

    mergedFlags |= ((newFlags & packingMask) ? newFlags : prevFlags) & packingMask;
    mergedFlags |= ((newFlags & matrixMask) ? newFlags : prevFlags) & matrixMask;

    return mergedFlags;
};

/**
 * glsUniformBlockCase.computeStd140Layout_B
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {number} curOffset
 * @param {number} curBlockNdx
 * @param {string} curPrefix
 * @param {glsUniformBlockCase.VarType} type
 * @param {number} layoutFlags
 * @return {number} //This is what would return in the curOffset output parameter in the original C++ project.
 */
glsUniformBlockCase.computeStd140Layout_B = function(layout, curOffset, curBlockNdx, curPrefix, type, layoutFlags) {
    /** @type {number} */ var baseAlignment = glsUniformBlockCase.computeStd140BaseAlignment(type);
    /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry;
    /** @type {number} */ var stride;
    /** @type {gluShaderUtil.DataType} */ var elemBasicType;
    /** @type {boolean} */ var isRowMajor;
    /** @type {number} */ var vecSize;
    /** @type {number} */ var numVecs;

    curOffset = deMath.deAlign32(curOffset, baseAlignment);

    if (type.isBasicType()) {
        /** @type {gluShaderUtil.DataType} */ var basicType = type.getBasicType();
        entry = new glsUniformBlockCase.UniformLayoutEntry();

        entry.name = curPrefix;
        entry.type = basicType;
        entry.size = 1;
        entry.arrayStride = 0;
        entry.matrixStride = 0;
        entry.blockNdx = curBlockNdx;

        if (gluShaderUtil.isDataTypeMatrix(basicType)) {
            // Array of vectors as specified in rules 5 & 7.
            isRowMajor = !!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
            vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(basicType) :
            gluShaderUtil.getDataTypeMatrixNumRows(basicType);
            numVecs = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(basicType) :
            gluShaderUtil.getDataTypeMatrixNumColumns(basicType);
            stride = glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));

            entry.offset = curOffset;
            entry.matrixStride = stride;
            entry.isRowMajor = isRowMajor;

            curOffset += numVecs * stride;
        } else {
            // Scalar or vector.
            entry.offset = curOffset;

            curOffset += glsUniformBlockCase.getDataTypeByteSize(basicType);
        }

        layout.uniforms.push(entry);
    } else if (type.isArrayType()) {
        /** @type {glsUniformBlockCase.VarType} */ var elemType = type.getElementType();

        if (elemType.isBasicType() && !gluShaderUtil.isDataTypeMatrix(elemType.getBasicType())) {
            // Array of scalars or vectors.
            elemBasicType = elemType.getBasicType();
            entry = new glsUniformBlockCase.UniformLayoutEntry();
            stride = glsUniformBlockCase.getDataTypeArrayStride(elemBasicType);

            entry.name = curPrefix + '[0]'; // Array uniforms are always postfixed with [0]
            entry.type = elemBasicType;
            entry.blockNdx = curBlockNdx;
            entry.offset = curOffset;
            entry.size = type.getArraySize();
            entry.arrayStride = stride;
            entry.matrixStride = 0;

            curOffset += stride * type.getArraySize();

            layout.uniforms.push(entry);
        } else if (elemType.isBasicType() && gluShaderUtil.isDataTypeMatrix(elemType.getBasicType())) {
            // Array of matrices.
            elemBasicType = elemType.getBasicType();
            isRowMajor = !!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
            vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(elemBasicType) :
            gluShaderUtil.getDataTypeMatrixNumRows(elemBasicType);
            numVecs = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(elemBasicType) :
            gluShaderUtil.getDataTypeMatrixNumColumns(elemBasicType);
            stride = glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));
            entry = new glsUniformBlockCase.UniformLayoutEntry();

            entry.name = curPrefix + '[0]'; // Array uniforms are always postfixed with [0]
            entry.type = elemBasicType;
            entry.blockNdx = curBlockNdx;
            entry.offset = curOffset;
            entry.size = type.getArraySize();
            entry.arrayStride = stride * numVecs;
            entry.matrixStride = stride;
            entry.isRowMajor = isRowMajor;

            curOffset += numVecs * type.getArraySize() * stride;

            layout.uniforms.push(entry);
        } else {
            DE_ASSERT(elemType.isStructType() || elemType.isArrayType());

            for (var elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++)
                curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, curBlockNdx, curPrefix + '[' + elemNdx + ']', type.getElementType(), layoutFlags);
        }
    } else {
        DE_ASSERT(type.isStructType());

        for (var memberNdx = 0; memberNdx < type.getStruct().getSize(); memberNdx++) {
            /** @type {glsUniformBlockCase.StructMember} */ var memberIter = type.getStruct().getMember(memberNdx);
            curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, curBlockNdx, curPrefix + '.' + memberIter.getName(), memberIter.getType(), layoutFlags);
        }

        curOffset = deMath.deAlign32(curOffset, baseAlignment);
    }

    return curOffset;
};

/**
 * glsUniformBlockCase.computeStd140Layout
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 */
glsUniformBlockCase.computeStd140Layout = function(layout, sinterface) {
    // \todo [2012-01-23 pyry] Uniforms in default block.

    /** @type {number} */ var numUniformBlocks = sinterface.getNumUniformBlocks();

    for (var blockNdx = 0; blockNdx < numUniformBlocks; blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
        /** @type {boolean} */ var hasInstanceName = block.getInstanceName() !== undefined;
        /** @type {string} */ var blockPrefix = hasInstanceName ? (block.getBlockName() + '.') : '';
        /** @type {number} */ var curOffset = 0;
        /** @type {number} */ var activeBlockNdx = layout.blocks.length;
        /** @type {number} */ var firstUniformNdx = layout.uniforms.length;

        for (var ubNdx = 0; ubNdx < block.countUniforms(); ubNdx++) {
            /** @type {glsUniformBlockCase.Uniform} */ var uniform = block.getUniform(ubNdx);
            curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, activeBlockNdx, blockPrefix + uniform.getName(), uniform.getType(), glsUniformBlockCase.mergeLayoutFlags(block.getFlags(), uniform.getFlags()));
        }

        /** @type {number} */ var uniformIndicesEnd = layout.uniforms.length;
        /** @type {number} */ var blockSize = curOffset;
        /** @type {number} */ var numInstances = block.isArray() ? block.getArraySize() : 1;

        // Create block layout entries for each instance.
        for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
            // Allocate entry for instance.
            layout.blocks.push(new glsUniformBlockCase.BlockLayoutEntry());
            /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var blockEntry = layout.blocks[layout.blocks.length - 1];

            blockEntry.name = block.getBlockName();
            blockEntry.size = blockSize;

            // Compute active uniform set for block.
            for (var uniformNdx = firstUniformNdx; uniformNdx < uniformIndicesEnd; uniformNdx++)
                blockEntry.activeUniformIndices.push(uniformNdx);

            if (block.isArray())
                blockEntry.name += '[' + instanceNdx + ']';
        }
    }
};

/**
 * glsUniformBlockCase.generateValue - Value generator
 * @param {glsUniformBlockCase.UniformLayoutEntry} entry
 * @param {Uint8Array} basePtr
 * @param {deRandom.Random} rnd
 */
glsUniformBlockCase.generateValue = function(entry, basePtr, rnd) {
    /** @type {gluShaderUtil.DataType}*/ var scalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(entry.type); //Using a more appropriate function in this case.
    /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(entry.type);
    /** @type {boolean} */ var isMatrix = gluShaderUtil.isDataTypeMatrix(entry.type);
    /** @type {number} */ var numVecs = isMatrix ? (entry.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(entry.type) : gluShaderUtil.getDataTypeMatrixNumColumns(entry.type)) : 1;
    /** @type {number} */ var vecSize = scalarSize / numVecs;
    /** @type {boolean} */ var isArray = entry.size > 1;
    /** @type {number} */ var compSize = deMath.INT32_SIZE;

    DE_ASSERT(scalarSize % numVecs == 0);

    for (var elemNdx = 0; elemNdx < entry.size; elemNdx++) {
        /** @type {Uint8Array} */ var elemPtr = basePtr.subarray(entry.offset + (isArray ? elemNdx * entry.arrayStride : 0));

        for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
            /** @type {Uint8Array} */ var vecPtr = elemPtr.subarray(isMatrix ? vecNdx * entry.matrixStride : 0);

            for (var compNdx = 0; compNdx < vecSize; compNdx++) {
                /** @type {Uint8Array} */ var compPtr = vecPtr.subarray(compSize * compNdx);
                /** @type {number} */ var _random;

                //Copy the random data byte per byte
                var _size = glsUniformBlockCase.getDataTypeByteSize(scalarType);

                var nbuffer = new ArrayBuffer(_size);
                var nview = new DataView(nbuffer);

                switch (scalarType) {
                    case gluShaderUtil.DataType.FLOAT:
                        _random = rnd.getInt(-9, 9);
                        nview.setFloat32(0, _random, littleEndian);
                        break;
                    case gluShaderUtil.DataType.INT:
                        _random = rnd.getInt(-9, 9);
                        nview.setInt32(0, _random, littleEndian);
                        break;
                    case gluShaderUtil.DataType.UINT:
                        _random = rnd.getInt(0, 9);
                        nview.setUint32(0, _random, littleEndian);
                        break;
                    // \note Random bit pattern is used for true values. Spec states that all non-zero values are
                    //       interpreted as true but some implementations fail this.
                    case gluShaderUtil.DataType.BOOL:
                        _random = rnd.getBool() ? 1 : 0;
                        nview.setUint32(0, _random, littleEndian);
                        break;
                    default:
                        DE_ASSERT(false);
                }

                for (var i = 0; i < _size; i++) {
                    compPtr[i] = nview.getUint8(i);
                }
            }
        }
    }
};

/**
 * glsUniformBlockCase.generateValues
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {glsUniformBlockCase.BlockPointers} blockPointers
 * @param {number} seed
 */
glsUniformBlockCase.generateValues = function(layout, blockPointers, seed) {
    /** @type  {deRandom.Random} */ var rnd = new deRandom.Random(seed);
    /** @type  {number} */ var numBlocks = layout.blocks.length;

    for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
        /** @type {Uint8Array} */ var basePtr = blockPointers.find(blockNdx);
        /** @type  {number} */ var numEntries = layout.blocks[blockNdx].activeUniformIndices.length;

        for (var entryNdx = 0; entryNdx < numEntries; entryNdx++) {
            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry = layout.uniforms[layout.blocks[blockNdx].activeUniformIndices[entryNdx]];
            glsUniformBlockCase.generateValue(entry, basePtr, rnd);
        }
    }
};

// Shader generator.

/**
 * glsUniformBlockCase.getCompareFuncForType
 * @param {gluShaderUtil.DataType} type
 * @return {string}
 */
glsUniformBlockCase.getCompareFuncForType = function(type) {
    switch (type) {
        case gluShaderUtil.DataType.FLOAT: return 'mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.FLOAT_VEC2: return 'mediump float compare_vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y); }\n';
        case gluShaderUtil.DataType.FLOAT_VEC3: return 'mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); }\n';
        case gluShaderUtil.DataType.FLOAT_VEC4: return 'mediump float compare_vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z)*compare_float(a.w, b.w); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT2: return 'mediump float compare_mat2 (highp mat2 a, highp mat2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 'mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 'mediump float compare_mat2x4 (highp mat2x4 a, highp mat2x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 'mediump float compare_mat3x2 (highp mat3x2 a, highp mat3x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT3: return 'mediump float compare_mat3 (highp mat3 a, highp mat3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 'mediump float compare_mat3x4 (highp mat3x4 a, highp mat3x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 'mediump float compare_mat4x2 (highp mat4x2 a, highp mat4x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2])*compare_vec2(a[3], b[3]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 'mediump float compare_mat4x3 (highp mat4x3 a, highp mat4x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2])*compare_vec3(a[3], b[3]); }\n';
        case gluShaderUtil.DataType.FLOAT_MAT4: return 'mediump float compare_mat4 (highp mat4 a, highp mat4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2])*compare_vec4(a[3], b[3]); }\n';
        case gluShaderUtil.DataType.INT: return 'mediump float compare_int (highp int a, highp int b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.INT_VEC2: return 'mediump float compare_ivec2 (highp ivec2 a, highp ivec2 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.INT_VEC3: return 'mediump float compare_ivec3 (highp ivec3 a, highp ivec3 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.INT_VEC4: return 'mediump float compare_ivec4 (highp ivec4 a, highp ivec4 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.UINT: return 'mediump float compare_uint (highp uint a, highp uint b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.UINT_VEC2: return 'mediump float compare_uvec2 (highp uvec2 a, highp uvec2 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.UINT_VEC3: return 'mediump float compare_uvec3 (highp uvec3 a, highp uvec3 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.UINT_VEC4: return 'mediump float compare_uvec4 (highp uvec4 a, highp uvec4 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.BOOL: return 'mediump float compare_bool (bool a, bool b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.BOOL_VEC2: return 'mediump float compare_bvec2 (bvec2 a, bvec2 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.BOOL_VEC3: return 'mediump float compare_bvec3 (bvec3 a, bvec3 b) { return a == b ? 1.0 : 0.0; }\n';
        case gluShaderUtil.DataType.BOOL_VEC4: return 'mediump float compare_bvec4 (bvec4 a, bvec4 b) { return a == b ? 1.0 : 0.0; }\n';
        default:
            throw new Error('Type "' + type + '" not supported.');

    }
};

/**
 * glsUniformBlockCase.getCompareDependencies
 * @param {Array<gluShaderUtil.DataType>} compareFuncs Should contain unique elements
 * @param {gluShaderUtil.DataType} basicType
 */
glsUniformBlockCase.getCompareDependencies = function(compareFuncs, basicType) {
    switch (basicType) {
        case gluShaderUtil.DataType.FLOAT_VEC2:
        case gluShaderUtil.DataType.FLOAT_VEC3:
        case gluShaderUtil.DataType.FLOAT_VEC4:
            deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.DataType.FLOAT);
            deUtil.dePushUniqueToArray(compareFuncs, basicType);
            break;

        case gluShaderUtil.DataType.FLOAT_MAT2:
        case gluShaderUtil.DataType.FLOAT_MAT2X3:
        case gluShaderUtil.DataType.FLOAT_MAT2X4:
        case gluShaderUtil.DataType.FLOAT_MAT3X2:
        case gluShaderUtil.DataType.FLOAT_MAT3:
        case gluShaderUtil.DataType.FLOAT_MAT3X4:
        case gluShaderUtil.DataType.FLOAT_MAT4X2:
        case gluShaderUtil.DataType.FLOAT_MAT4X3:
        case gluShaderUtil.DataType.FLOAT_MAT4:
            deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.DataType.FLOAT);
            deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.getDataTypeFloatVec(gluShaderUtil.getDataTypeMatrixNumRows(basicType)));
            deUtil.dePushUniqueToArray(compareFuncs, basicType);
            break;

        default:
            deUtil.dePushUniqueToArray(compareFuncs, basicType);
            break;
    }
};

/**
 * glsUniformBlockCase.collectUniqueBasicTypes_B
 * @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
 * @param {glsUniformBlockCase.VarType} type
 */
glsUniformBlockCase.collectUniqueBasicTypes_B = function(basicTypes, type) {
    if (type.isStructType()) {
        /** @type {glsUniformBlockCase.StructType} */ var stype = type.getStruct();
        for (var memberNdx = 0; memberNdx < stype.getSize(); memberNdx++)
            glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, stype.getMember(memberNdx).getType());
    } else if (type.isArrayType())
        glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, type.getElementType());
    else {
        DE_ASSERT(type.isBasicType());
        deUtil.dePushUniqueToArray(basicTypes, type.getBasicType());
    }
};

/**
 * glsUniformBlockCase.collectUniqueBasicTypes_A
 * @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
 * @param {glsUniformBlockCase.UniformBlock} uniformBlock
 */
glsUniformBlockCase.collectUniqueBasicTypes_A = function(basicTypes, uniformBlock) {
    for (var uniformNdx = 0; uniformNdx < uniformBlock.countUniforms(); uniformNdx++)
        glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, uniformBlock.getUniform(uniformNdx).getType());
};

/**
 * glsUniformBlockCase.collectUniqueBasicTypes
 * @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 */
glsUniformBlockCase.collectUniqueBasicTypes = function(basicTypes, sinterface) {
    for (var ndx = 0; ndx < sinterface.getNumUniformBlocks(); ++ndx)
        glsUniformBlockCase.collectUniqueBasicTypes_A(basicTypes, sinterface.getUniformBlock(ndx));
};

/**
 * glsUniformBlockCase.collectUniqueBasicTypes
 * @return {string} Was originally an output parameter. As it is a basic type, we have to return it instead.
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 */
glsUniformBlockCase.generateCompareFuncs = function(sinterface) {
    /** @type {string} */ var str = '';
    /** @type {Array<gluShaderUtil.DataType>} */ var types = []; //Will contain unique elements.
    /** @type {Array<gluShaderUtil.DataType>} */ var compareFuncs = []; //Will contain unique elements.

    // Collect unique basic types
    glsUniformBlockCase.collectUniqueBasicTypes(types, sinterface);

    // Set of compare functions required
    for (var typeNdx = 0; typeNdx < types.length; typeNdx++)
        glsUniformBlockCase.getCompareDependencies(compareFuncs, types[typeNdx]);

    for (var type in gluShaderUtil.DataType) {
        if (compareFuncs.indexOf(gluShaderUtil.DataType[type]) > -1)
            str += glsUniformBlockCase.getCompareFuncForType(gluShaderUtil.DataType[type]);
    }

    return str;
};

/**
 * glsUniformBlockCase.Indent - Prints level_ number of tab chars
 * @param {number} level_
 * @return {string}
 */
glsUniformBlockCase.Indent = function(level_) {
    var str = '';
    for (var i = 0; i < level_; i++)
        str += '\t';

    return str;
};

/**
 * glsUniformBlockCase.generateDeclaration_C
 * @return {string} src
 * @param {glsUniformBlockCase.StructType} structType
 * @param {number} indentLevel
 */
glsUniformBlockCase.generateDeclaration_C = function(structType, indentLevel) {
    /** @type {string} */ var src = '';

    DE_ASSERT(structType.getTypeName() !== undefined);
    src += glsUniformBlockCase.generateFullDeclaration(structType, indentLevel);
    src += ';\n';

    return src;
};

/**
 * glsUniformBlockCase.generateFullDeclaration
 * @return {string} src
 * @param {glsUniformBlockCase.StructType} structType
 * @param {number} indentLevel
 */
glsUniformBlockCase.generateFullDeclaration = function(structType, indentLevel) {
    var src = 'struct';
    if (structType.getTypeName())
        src += ' ' + structType.getTypeName();
    src += '\n' + glsUniformBlockCase.Indent(indentLevel) + ' {\n';

    for (var memberNdx = 0; memberNdx < structType.getSize(); memberNdx++) {
        src += glsUniformBlockCase.Indent(indentLevel + 1);
        /** @type {glsUniformBlockCase.StructMember} */ var memberIter = structType.getMember(memberNdx);
        src += glsUniformBlockCase.generateDeclaration_B(memberIter.getType(), memberIter.getName(), indentLevel + 1, memberIter.getFlags() & glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
    }

    src += glsUniformBlockCase.Indent(indentLevel) + '}';

    return src;
};

/**
 * glsUniformBlockCase.generateLocalDeclaration
 * @return {string} src
 * @param {glsUniformBlockCase.StructType} structType
 * @param {number} indentLevel
 */
glsUniformBlockCase.generateLocalDeclaration = function(structType, indentLevel) {
    /** @type {string} */ var src = '';

    if (structType.getTypeName() === undefined)
        src += glsUniformBlockCase.generateFullDeclaration(structType, indentLevel);
    else
        src += structType.getTypeName();

    return src;
};

/**
 * glsUniformBlockCase.generateDeclaration_B
 * @return {string} src
 * @param {glsUniformBlockCase.VarType} type
 * @param {string} name
 * @param {number} indentLevel
 * @param {number} unusedHints
 */
glsUniformBlockCase.generateDeclaration_B = function(type, name, indentLevel, unusedHints) {
    /** @type {string} */ var src = '';
    /** @type {number} */ var flags = type.getFlags();

    if ((flags & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
        src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(flags & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';

    if ((flags & glsUniformBlockCase.UniformFlags.PRECISION_MASK) != 0)
        src += glsUniformBlockCase.PrecisionFlagsFmt(flags & glsUniformBlockCase.UniformFlags.PRECISION_MASK) + ' ';

    if (type.isBasicType())
        src += gluShaderUtil.getDataTypeName(type.getBasicType()) + ' ' + name;
    else if (type.isArrayType()) {
        /** @type {Array<number>} */ var arraySizes = [];
        /** @type {glsUniformBlockCase.VarType} */ var curType = type;
        while (curType.isArrayType()) {
            arraySizes.push(curType.getArraySize());
            curType = curType.getElementType();
        }

        if (curType.isBasicType()) {
            if ((curType.getFlags() & glsUniformBlockCase.UniformFlags.PRECISION_MASK) != 0)
                src += glsUniformBlockCase.PrecisionFlagsFmt(curType.getFlags() & glsUniformBlockCase.UniformFlags.PRECISION_MASK) + ' ';
            src += gluShaderUtil.getDataTypeName(curType.getBasicType());
        } else {
            DE_ASSERT(curType.isStructType());
            src += glsUniformBlockCase.generateLocalDeclaration(curType.getStruct(), indentLevel + 1);
        }

        src += ' ' + name;

        for (var sizeNdx = 0; sizeNdx < arraySizes.length; sizeNdx++)
            src += '[' + arraySizes[sizeNdx] + ']';
    } else {
        src += glsUniformBlockCase.generateLocalDeclaration(type.getStruct(), indentLevel + 1);
        src += ' ' + name;
    }

    src += ';';

    // Print out unused hints.
    if (unusedHints != 0)
        src += ' // unused in ' + (unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_BOTH ? 'both shaders' :
                                    unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_VERTEX ? 'vertex shader' :
                                    unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT ? 'fragment shader' : '???');

    src += '\n';

    return src;
};

/**
 * glsUniformBlockCase.generateDeclaration_A
 * @return {string} src
 * @param {glsUniformBlockCase.Uniform} uniform
 * @param {number} indentLevel
 */
glsUniformBlockCase.generateDeclaration_A = function(uniform, indentLevel) {
    /** @type {string} */ var src = '';

    if ((uniform.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
        src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(uniform.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';

    src += glsUniformBlockCase.generateDeclaration_B(uniform.getType(), uniform.getName(), indentLevel, uniform.getFlags() & glsUniformBlockCase.UniformFlags.UNUSED_BOTH);

    return src;
};

/**
 * glsUniformBlockCase.generateDeclaration
 * @return {string} src
 * @param {glsUniformBlockCase.UniformBlock} block
 */
glsUniformBlockCase.generateDeclaration = function(block) {
    /** @type {string} */ var src = '';

    if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
        src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';

    src += 'uniform ' + block.getBlockName();
    src += '\n {\n';

    for (var uniformNdx = 0; uniformNdx < block.countUniforms(); uniformNdx++) {
        src += glsUniformBlockCase.Indent(1);
        src += glsUniformBlockCase.generateDeclaration_A(block.getUniform(uniformNdx), 1 /* indent level */);
    }

    src += '}';

    if (block.getInstanceName() !== undefined) {
        src += ' ' + block.getInstanceName();
        if (block.isArray())
            src += '[' + block.getArraySize() + ']';
    } else
        DE_ASSERT(!block.isArray());

    src += ';\n';

    return src;
};

/**
 * glsUniformBlockCase.newArrayBufferFromView - Creates a new buffer copying data from a given view
 * @param {goog.NumberArray} view
 * @return {ArrayBuffer} The newly created buffer
 */
glsUniformBlockCase.newArrayBufferFromView = function(view) {
    var buffer = new ArrayBuffer(view.length * view.BYTES_PER_ELEMENT);
    var copyview;
    switch (view.BYTES_PER_ELEMENT) {
        case 1:
            copyview = new Uint8Array(buffer); break;
        case 2:
            copyview = new Uint16Array(buffer); break;
        case 4:
            copyview = new Uint32Array(buffer); break;
        default:
            assertMsgOptions(false, 'Unexpected value for BYTES_PER_ELEMENT in view', false, true);
    }
    for (var i = 0; i < view.length; i++)
        copyview[i] = view[i];

    return buffer;
};

/**
 * glsUniformBlockCase.generateValueSrc
 * @return {string} Used to be an output parameter in C++ project
 * @param {glsUniformBlockCase.UniformLayoutEntry} entry
 * @param {Uint8Array} basePtr
 * @param {number} elementNdx
 */
glsUniformBlockCase.generateValueSrc = function(entry, basePtr, elementNdx) {
    /** @type {string} */ var src = '';
    /** @type {gluShaderUtil.DataType} */ var scalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(entry.type);
    /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(entry.type);
    /** @type {boolean} */ var isArray = entry.size > 1;
    /** @type {Uint8Array} */ var elemPtr = basePtr.subarray(entry.offset + (isArray ? elementNdx * entry.arrayStride : 0));
    /** @type {number} */ var compSize = deMath.INT32_SIZE;
    /** @type {Uint8Array} */ var compPtr;
    if (scalarSize > 1)
        src += gluShaderUtil.getDataTypeName(entry.type) + '(';

    if (gluShaderUtil.isDataTypeMatrix(entry.type)) {
        /** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(entry.type);
        /** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(entry.type);

        DE_ASSERT(scalarType == gluShaderUtil.DataType.FLOAT);

        // Constructed in column-wise order.
        for (var colNdx = 0; colNdx < numCols; colNdx++) {
            for (var rowNdx = 0; rowNdx < numRows; rowNdx++) {
                compPtr = elemPtr.subarray(entry.isRowMajor ? rowNdx * entry.matrixStride + colNdx * compSize :
                                                                      colNdx * entry.matrixStride + rowNdx * compSize);

                if (colNdx > 0 || rowNdx > 0)
                    src += ', ';

                var newbuffer = new Uint8Array(compPtr.subarray(0, 4)).buffer;
                var newview = new DataView(newbuffer);
                src += parseFloat(newview.getFloat32(0, littleEndian)).toFixed(1);
            }
        }
    } else {
        for (var scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++) {
            compPtr = elemPtr.subarray(scalarNdx * compSize);

            if (scalarNdx > 0)
                src += ', ';

            var newbuffer = glsUniformBlockCase.newArrayBufferFromView(compPtr.subarray(0, 4));
            var newview = new DataView(newbuffer);

            switch (scalarType) {
                case gluShaderUtil.DataType.FLOAT: src += parseFloat(newview.getFloat32(0, littleEndian) * 100 / 100).toFixed(1); break;
                case gluShaderUtil.DataType.INT: src += newview.getInt32(0, littleEndian); break;
                case gluShaderUtil.DataType.UINT: src += newview.getUint32(0, littleEndian) + 'u'; break;
                case gluShaderUtil.DataType.BOOL: src += (newview.getUint32(0, littleEndian) != 0 ? 'true' : 'false'); break;
                default:
                    DE_ASSERT(false);
            }
        }
    }

    if (scalarSize > 1)
        src += ')';

    return src;
};

/**
 * glsUniformBlockCase.generateCompareSrc_A
 * @return {string} Used to be an output parameter in C++ project
 * @param {string} resultVar
 * @param {glsUniformBlockCase.VarType} type
 * @param {string} srcName
 * @param {string} apiName
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {Uint8Array} basePtr
 * @param {number} unusedMask
 */
glsUniformBlockCase.generateCompareSrc_A = function(resultVar, type, srcName, apiName, layout, basePtr, unusedMask) {
    /** @type {string} */ var src = '';
    /** @type {string} */ var op;
    /** @type {glsUniformBlockCase.VarType|gluShaderUtil.DataType} */ var elementType;

    if (type.isBasicType() || (type.isArrayType() && type.getElementType().isBasicType())) {
        // Basic type or array of basic types.
        /** @type {boolean} */ var isArray = type.isArrayType();
        elementType = isArray ? type.getElementType().getBasicType() : type.getBasicType();
        /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(elementType);
        /** @type {string} */ var fullApiName = apiName + (isArray ? '[0]' : ''); // Arrays are always postfixed with [0]
        /** @type {number} */ var uniformNdx = layout.getUniformIndex(fullApiName);
        /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry = layout.uniforms[uniformNdx];

        if (isArray) {
            for (var elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++) {
                src += '\tresult *= compare_' + typeName + '(' + srcName + '[' + elemNdx + '], ';
                src += glsUniformBlockCase.generateValueSrc(entry, basePtr, elemNdx);
                src += ');\n';
            }
        } else {
            src += '\tresult *= compare_' + typeName + '(' + srcName + ', ';
            src += glsUniformBlockCase.generateValueSrc(entry, basePtr, 0);
            src += ');\n';
        }
    } else if (type.isArrayType()) {
        elementType = type.getElementType();

        for (var elementNdx = 0; elementNdx < type.getArraySize(); elementNdx++) {
            op = '[' + elementNdx + ']';
            src += glsUniformBlockCase.generateCompareSrc_A(resultVar, elementType, srcName + op, apiName + op, layout, basePtr, unusedMask);
        }
    } else {
        DE_ASSERT(type.isStructType());

        /** @type {glsUniformBlockCase.StructType} */ var stype = type.getStruct();
        for (var memberNdx = 0; memberNdx < stype.getSize(); memberNdx++) {
            /** @type {glsUniformBlockCase.StructMember} */ var memberIter = stype.getMember(memberNdx);
            if (memberIter.getFlags() & unusedMask)
                continue; // Skip member.

            op = '.' + memberIter.getName();
            src += glsUniformBlockCase.generateCompareSrc_A(resultVar, memberIter.getType(), srcName + op, apiName + op, layout, basePtr, unusedMask);
        }
    }

    return src;
};

/**
 * glsUniformBlockCase.generateCompareSrc
 * @return {string} Used to be an output parameter in C++ project
 * @param {string} resultVar
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {glsUniformBlockCase.BlockPointers} blockPointers
 * @param {boolean} isVertex
 */
glsUniformBlockCase.generateCompareSrc = function(resultVar, sinterface, layout, blockPointers, isVertex) {
    /** @type {string} */ var src = '';
    /** @type {number} */ var unusedMask = isVertex ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT;

    for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);

        if ((block.getFlags() & (isVertex ? glsUniformBlockCase.UniformFlags.DECLARE_VERTEX : glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) == 0)
            continue; // Skip.

        /** @type {boolean} */ var hasInstanceName = block.getInstanceName() !== undefined;
        /** @type {boolean} */ var isArray = block.isArray();
        /** @type {number} */ var numInstances = isArray ? block.getArraySize() : 1;
        /** @type {string} */ var apiPrefix = hasInstanceName ? block.getBlockName() + '.' : '';

        DE_ASSERT(!isArray || hasInstanceName);

        for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
            /** @type {string} */ var instancePostfix = isArray ? '[' + instanceNdx + ']' : '';
            /** @type {string} */ var blockInstanceName = block.getBlockName() + instancePostfix;
            /** @type {string} */ var srcPrefix = hasInstanceName ? block.getInstanceName() + instancePostfix + '.' : '';
            /** @type {number} */ var activeBlockNdx = layout.getBlockIndex(blockInstanceName);
            /** @type {Uint8Array} */ var basePtr = blockPointers.find(activeBlockNdx);

            for (var uniformNdx = 0; uniformNdx < block.countUniforms(); uniformNdx++) {
                /** @type {glsUniformBlockCase.Uniform} */ var uniform = block.getUniform(uniformNdx);

                if (uniform.getFlags() & unusedMask)
                    continue; // Don't read from that uniform.

                src += glsUniformBlockCase.generateCompareSrc_A(resultVar, uniform.getType(), srcPrefix + uniform.getName(), apiPrefix + uniform.getName(), layout, basePtr, unusedMask);
            }
        }
    }

    return src;
};

/**
 * glsUniformBlockCase.generateVertexShader
 * @return {string} src
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {glsUniformBlockCase.BlockPointers} blockPointers
 */
glsUniformBlockCase.generateVertexShader = function(sinterface, layout, blockPointers) {
    /** @type {string} */ var src = '';

    DE_ASSERT(glsUniformBlockCase.isSupportedGLSLVersion(gluShaderUtil.getGLSLVersion(gl)));

    src += gluShaderUtil.getGLSLVersionDeclaration(gluShaderUtil.getGLSLVersion(gl)) + '\n';
    src += 'in highp vec4 a_position;\n';
    src += 'out mediump float v_vtxResult;\n';
    src += '\n';

    /** @type {Array<glsUniformBlockCase.StructType>} */ var namedStructs = [];
    sinterface.getNamedStructs(namedStructs);
    for (var structNdx = 0; structNdx < namedStructs.length; structNdx++)
        src += glsUniformBlockCase.generateDeclaration_C(namedStructs[structNdx], 0);

    for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
        if (block.getFlags() & glsUniformBlockCase.UniformFlags.DECLARE_VERTEX)
            src += glsUniformBlockCase.generateDeclaration(block);
    }

    // Comparison utilities.
    src += '\n';
    src += glsUniformBlockCase.generateCompareFuncs(sinterface);

    src += '\n' +
           'void main (void)\n' +
           ' {\n' +
           ' gl_Position = a_position;\n' +
           ' mediump float result = 1.0;\n';

    // Value compare.
    src += glsUniformBlockCase.generateCompareSrc('result', sinterface, layout, blockPointers, true);

    src += ' v_vtxResult = result;\n' +
           '}\n';

    return src;
};

/**
 * glsUniformBlockCase.generateFragmentShader
 * @return {string} Used to be an output parameter
 * @param {glsUniformBlockCase.ShaderInterface} sinterface
 * @param {glsUniformBlockCase.UniformLayout} layout
 * @param {glsUniformBlockCase.BlockPointers} blockPointers
 */
glsUniformBlockCase.generateFragmentShader = function(sinterface, layout, blockPointers) {
    /** @type {string} */ var src = '';
    DE_ASSERT(glsUniformBlockCase.isSupportedGLSLVersion(gluShaderUtil.getGLSLVersion(gl)));

    src += gluShaderUtil.getGLSLVersionDeclaration(gluShaderUtil.getGLSLVersion(gl)) + '\n';
    src += 'in mediump float v_vtxResult;\n';
    src += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
    src += '\n';

    /** @type {Array<glsUniformBlockCase.StructType>} */ var namedStructs = [];
    sinterface.getNamedStructs(namedStructs);
    for (var structNdx = 0; structNdx < namedStructs.length; structNdx++)
        src += glsUniformBlockCase.generateDeclaration_C(namedStructs[structNdx], 0);

    for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
        if (block.getFlags() & glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)
            src += glsUniformBlockCase.generateDeclaration(block);
    }

    // Comparison utilities.
    src += '\n';
    src += glsUniformBlockCase.generateCompareFuncs(sinterface);

    src += '\n' +
           'void main (void)\n' +
           ' {\n' +
           ' mediump float result = 1.0;\n';

    // Value compare.
    src += glsUniformBlockCase.generateCompareSrc('result', sinterface, layout, blockPointers, false);

    src += ' dEQP_FragColor = vec4(1.0, v_vtxResult, result, 1.0);\n' +
           '}\n';

    return src;
};

/**
 * TODO: test glsUniformBlockCase.getGLUniformLayout Gets the uniform blocks and uniforms in the program.
 * @param {WebGL2RenderingContext} gl
 * @param {glsUniformBlockCase.UniformLayout} layout To store the layout described in program.
 * @param {WebGLProgram} program id
 */
glsUniformBlockCase.getGLUniformLayout = function(gl, layout, program) {
    /** @type {number} */ var numActiveUniforms = 0;
    /** @type {number} */ var numActiveBlocks = 0;

    numActiveUniforms = /** @type {number} */ (gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS)); // ACTIVE_UNIFORM* returns GLInt
    numActiveBlocks = /** @type {number} */ (gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS));

    /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var entryBlock;
    /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entryUniform;
    /** @type {number} */ var size;
    /** @type {number} */ var nameLen;
    /** @type {string} */ var nameBuf;
    /** @type {number} */ var numBlockUniforms;

    // Block entries.
    //No need to allocate these beforehand: layout.blocks.resize(numActiveBlocks);
    for (var blockNdx = 0; blockNdx < numActiveBlocks; blockNdx++) {
        entryBlock = new glsUniformBlockCase.BlockLayoutEntry();

        size = /** @type {number} */ (gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_DATA_SIZE));
        // nameLen not used so this line is removed.
        // nameLen = gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_NAME_LENGTH); // TODO: UNIFORM_BLOCK_NAME_LENGTH is removed in WebGL2
        numBlockUniforms = /** @type {number} */ (gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS));

        nameBuf = gl.getActiveUniformBlockName(program, blockNdx);

        entryBlock.name = nameBuf;
        entryBlock.size = size;
        //entry.activeUniformIndices.resize(numBlockUniforms);

        if (numBlockUniforms > 0)
            entryBlock.activeUniformIndices = gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);

        layout.blocks.push(entryBlock); //Pushing the block into the array here.
    }

    if (numActiveUniforms > 0) {
        // glsUniformBlockCase.Uniform entries.
        /** @type {Array<number>} */ var uniformIndices = [];
        for (var i = 0; i < numActiveUniforms; i++)
            uniformIndices.push(i);

        /** @type {Array<number>} */ var types = [];
        /** @type {Array<number>} */ var sizes = [];
        /** @type {Array<number>} */ var nameLengths = [];
        /** @type {Array<number>} */ var blockIndices = [];
        /** @type {Array<number>} */ var offsets = [];
        /** @type {Array<number>} */ var arrayStrides = [];
        /** @type {Array<number>} */ var matrixStrides = [];
        /** @type {Array<number>} */ var rowMajorFlags = [];

        // Execute queries.
        types = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_TYPE);
        sizes = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_SIZE);
        // Remove this: nameLengths = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_NAME_LENGTH);
        blockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX);
        offsets = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_OFFSET);
        arrayStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_ARRAY_STRIDE);
        matrixStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_MATRIX_STRIDE);
        rowMajorFlags = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_IS_ROW_MAJOR);

        // Translate to LayoutEntries
        // No resize needed. Will push them: layout.uniforms.resize(numActiveUniforms);
        for (var uniformNdx = 0; uniformNdx < numActiveUniforms; uniformNdx++) {
            entryUniform = new glsUniformBlockCase.UniformLayoutEntry();

            // Remove this: nameLen = 0;
            size = 0;
            /** @type {number} */ var type = gl.NONE;

            var uniform = gl.getActiveUniform(program, uniformNdx);

            nameBuf = uniform.name;
            // Remove this: nameLen = nameBuf.length;
            size = uniform.size;
            type = uniform.type;

            // Remove this: nameLen != nameLengths[uniformNdx] ||
            if (size != sizes[uniformNdx] ||
                type != types[uniformNdx])
                testFailedOptions("Values returned by gl.getActiveUniform() don't match with values queried with gl.getActiveUniforms().", true);

            entryUniform.name = nameBuf;
            entryUniform.type = gluShaderUtil.getDataTypeFromGLType(types[uniformNdx]);
            entryUniform.size = sizes[uniformNdx];
            entryUniform.blockNdx = blockIndices[uniformNdx];
            entryUniform.offset = offsets[uniformNdx];
            entryUniform.arrayStride = arrayStrides[uniformNdx];
            entryUniform.matrixStride = matrixStrides[uniformNdx];
            entryUniform.isRowMajor = rowMajorFlags[uniformNdx] != false;

            layout.uniforms.push(entryUniform); //Pushing this uniform in the end.
        }
    }
};

/**
 * glsUniformBlockCase.copyUniformData_A - Copies a source uniform buffer segment to a destination uniform buffer segment.
 * @param {glsUniformBlockCase.UniformLayoutEntry} dstEntry
 * @param {Uint8Array} dstBlockPtr
 * @param {glsUniformBlockCase.UniformLayoutEntry} srcEntry
 * @param {Uint8Array} srcBlockPtr
 */
glsUniformBlockCase.copyUniformData_A = function(dstEntry, dstBlockPtr, srcEntry, srcBlockPtr) {
    /** @type {Uint8Array} */ var dstBasePtr = dstBlockPtr.subarray(dstEntry.offset);
    /** @type {Uint8Array} */ var srcBasePtr = srcBlockPtr.subarray(srcEntry.offset);

    DE_ASSERT(dstEntry.size <= srcEntry.size);
    DE_ASSERT(dstEntry.type == srcEntry.type);

    /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(dstEntry.type);
    /** @type {boolean} */ var isMatrix = gluShaderUtil.isDataTypeMatrix(dstEntry.type);
    /** @type {number} */ var compSize = deMath.INT32_SIZE;

    for (var elementNdx = 0; elementNdx < dstEntry.size; elementNdx++) {
        /** @type {Uint8Array} */ var dstElemPtr = dstBasePtr.subarray(elementNdx * dstEntry.arrayStride);
        /** @type {Uint8Array} */ var srcElemPtr = srcBasePtr.subarray(elementNdx * srcEntry.arrayStride);

        if (isMatrix) {
            /** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(dstEntry.type);
            /** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(dstEntry.type);

            for (var colNdx = 0; colNdx < numCols; colNdx++) {
                for (var rowNdx = 0; rowNdx < numRows; rowNdx++) {
                    var srcoffset = dstEntry.isRowMajor ? rowNdx * dstEntry.matrixStride + colNdx * compSize :
                                    colNdx * dstEntry.matrixStride + rowNdx * compSize;
                    /** @type {Uint8Array} */ var dstCompPtr = dstElemPtr.subarray(srcoffset, srcoffset + compSize);
                    var dstoffset = srcEntry.isRowMajor ? rowNdx * srcEntry.matrixStride + colNdx * compSize :
                                    colNdx * srcEntry.matrixStride + rowNdx * compSize;
                    /** @type {Uint8Array} */ var srcCompPtr = srcElemPtr.subarray(dstoffset, dstoffset + compSize);

                    //Copy byte per byte
                    for (var i = 0; i < compSize; i++)
                        dstCompPtr[i] = srcCompPtr[i];
                }
            }
        } else
            //Copy byte per byte
            for (var i = 0; i < scalarSize * compSize; i++)
                dstElemPtr[i] = srcElemPtr[i];
    }
};

/**
 * glsUniformBlockCase.copyUniformData - Copies a source uniform buffer to a destination uniform buffer.
 * @param {glsUniformBlockCase.UniformLayout} dstLayout
 * @param {glsUniformBlockCase.BlockPointers} dstBlockPointers
 * @param {glsUniformBlockCase.UniformLayout} srcLayout
 * @param {glsUniformBlockCase.BlockPointers} srcBlockPointers
 */
glsUniformBlockCase.copyUniformData = function(dstLayout, dstBlockPointers, srcLayout, srcBlockPointers) {
    // \note Src layout is used as reference in case of activeUniforms happens to be incorrect in dstLayout blocks.
    /** @type {number} */ var numBlocks = srcLayout.blocks.length;

    for (var srcBlockNdx = 0; srcBlockNdx < numBlocks; srcBlockNdx++) {
        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var srcBlock = srcLayout.blocks[srcBlockNdx];
        /** @type {Uint8Array} */ var srcBlockPtr = srcBlockPointers.find(srcBlockNdx);
        /** @type {number} */ var dstBlockNdx = dstLayout.getBlockIndex(srcBlock.name);
        /** @type {Uint8Array} */ var dstBlockPtr = dstBlockNdx >= 0 ? dstBlockPointers.find(dstBlockNdx) : null;

        if (dstBlockNdx < 0)
            continue;

        for (var srcUniformNdx = 0; srcUniformNdx < srcBlock.activeUniformIndices.length; srcUniformNdx++) {
            /** @type {number} */ var srcUniformNdxIter = srcBlock.activeUniformIndices[srcUniformNdx];
            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var srcEntry = srcLayout.uniforms[srcUniformNdxIter];
            /** @type {number} */ var dstUniformNdx = dstLayout.getUniformIndex(srcEntry.name);

            if (dstUniformNdx < 0)
                continue;

            glsUniformBlockCase.copyUniformData_A(dstLayout.uniforms[dstUniformNdx], dstBlockPtr, srcEntry, srcBlockPtr);
        }
    }
};

 /**
  * TODO: Test with an actual WebGL 2.0 context
  * iterate - The actual execution of the test.
  * @return {tcuTestCase.IterateResult}
  */
 glsUniformBlockCase.UniformBlockCase.prototype.iterate = function() {
    /** @type {glsUniformBlockCase.UniformLayout} */ var refLayout = new glsUniformBlockCase.UniformLayout(); //!< std140 layout.
    /** @type {glsUniformBlockCase.BlockPointers} */ var blockPointers = new glsUniformBlockCase.BlockPointers();

    // Compute reference layout.
    glsUniformBlockCase.computeStd140Layout(refLayout, this.m_interface);

    // Assign storage for reference values.
    /** @type {number} */ var totalSize = 0;
    for (var blockNdx = 0; blockNdx < refLayout.blocks.length; blockNdx++) {
        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var blockIter = refLayout.blocks[blockNdx];
        totalSize += blockIter.size;
    }
    blockPointers.resize(totalSize);

    // Pointers for each block.
    var curOffset = 0;
    for (var blockNdx = 0; blockNdx < refLayout.blocks.length; blockNdx++) {
        var size = refLayout.blocks[blockNdx].size;
        blockPointers.push(curOffset, size);
        curOffset += size;
    }

    // Generate values.
    glsUniformBlockCase.generateValues(refLayout, blockPointers, 1 /* seed */);

    // Generate shaders and build program.
    /** @type {string} */ var vtxSrc = glsUniformBlockCase.generateVertexShader(this.m_interface, refLayout, blockPointers);
    /** @type {string} */ var fragSrc = glsUniformBlockCase.generateFragmentShader(this.m_interface, refLayout, blockPointers);

    /** @type {gluShaderProgram.ShaderProgram}*/ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSrc, fragSrc));
    bufferedLogToConsole(program.getProgramInfo().infoLog);

    if (!program.isOk()) {
        // Compile failed.
        testFailedOptions('Compile failed', false);
        return tcuTestCase.IterateResult.STOP;
    }

    // Query layout from GL.
    /** @type {glsUniformBlockCase.UniformLayout} */ var glLayout = new glsUniformBlockCase.UniformLayout();
    glsUniformBlockCase.getGLUniformLayout(gl, glLayout, program.getProgram());

    // Print layout to log.
    bufferedLogToConsole('Active glsUniformBlockCase.Uniform Blocks');
    for (var blockNdx = 0; blockNdx < glLayout.blocks.length; blockNdx++)
        bufferedLogToConsole(blockNdx + ': ' + glLayout.blocks[blockNdx]);

    bufferedLogToConsole('Active Uniforms');
     for (var uniformNdx = 0; uniformNdx < glLayout.uniforms.length; uniformNdx++)
         bufferedLogToConsole(uniformNdx + ': ' + glLayout.uniforms[uniformNdx]);

    // Check that we can even try rendering with given layout.
    if (!this.checkLayoutIndices(glLayout) || !this.checkLayoutBounds(glLayout) || !this.compareTypes(refLayout, glLayout)) {
        testFailedOptions('Invalid layout', false);
        return tcuTestCase.IterateResult.STOP; // It is not safe to use the given layout.
    }

    // Verify all std140 blocks.
    if (!this.compareStd140Blocks(refLayout, glLayout))
        testFailedOptions('Invalid std140 layout', false);

    // Verify all shared blocks - all uniforms should be active, and certain properties match.
    if (!this.compareSharedBlocks(refLayout, glLayout))
        testFailedOptions('Invalid shared layout', false);

    // Check consistency with index queries
    if (!this.checkIndexQueries(program.getProgram(), glLayout))
        testFailedOptions('Inconsintent block index query results', false);

    // Use program.
    gl.useProgram(program.getProgram());

    /** @type {number} */ var binding;
    /** @type {WebGLBuffer} */ var buffer;

    // Assign binding points to all active uniform blocks.
    for (var blockNdx = 0; blockNdx < glLayout.blocks.length; blockNdx++) {
        binding = blockNdx; // \todo [2012-01-25 pyry] Randomize order?
        gl.uniformBlockBinding(program.getProgram(), blockNdx, binding);
    }

    /** @type {number} */ var numBlocks;
    /** @type {glsUniformBlockCase.BlockPointers} */ var glBlockPointers;

    // Allocate buffers, write data and bind to targets.
    /** @type {glsUniformBlockCase.UniformBufferManager} */ var bufferManager = new glsUniformBlockCase.UniformBufferManager(gl);
    if (this.m_bufferMode == glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK) {
        numBlocks = glLayout.blocks.length;
        glBlockPointers = new glsUniformBlockCase.BlockPointers();

        var totalsize = 0;
        for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++)
            totalsize += glLayout.blocks[blockNdx].size;

        glBlockPointers.resize(totalsize);

        var offset = 0;
        for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
            glBlockPointers.push(offset, glLayout.blocks[blockNdx].size);
            offset += glLayout.blocks[blockNdx].size;
        }

        glsUniformBlockCase.copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers);

        for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
            buffer = bufferManager.allocBuffer();
            binding = blockNdx;
            gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
            gl.bufferData(gl.UNIFORM_BUFFER, glBlockPointers.find(blockNdx) /*(glw::GLsizeiptr)glData[blockNdx].size(), &glData[blockNdx][0]*/, gl.STATIC_DRAW);
            gl.bindBufferBase(gl.UNIFORM_BUFFER, binding, buffer);
        }
    } else {
        DE_ASSERT(this.m_bufferMode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE);

        totalSize = 0;
        curOffset = 0;
        numBlocks = glLayout.blocks.length;
        /** @type {number} */ var bindingAlignment = 0;
        glBlockPointers = new glsUniformBlockCase.BlockPointers();

        bindingAlignment = /** @type {number} */ (gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT));

        // Compute total size and offsets.
        curOffset = 0;
        for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
            if (bindingAlignment > 0)
                curOffset = glsUniformBlockCase.deRoundUp32(curOffset, bindingAlignment);
            glBlockPointers.push(curOffset, glLayout.blocks[blockNdx].size);
            curOffset += glLayout.blocks[blockNdx].size;
        }
        totalSize = curOffset;
        glBlockPointers.resize(totalSize);

        // Copy to gl format.
        glsUniformBlockCase.copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers);

        // Allocate buffer and upload data.
        buffer = bufferManager.allocBuffer();
        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
        if (glBlockPointers.data.byteLength > 0 /*!glData.empty()*/)
            gl.bufferData(gl.UNIFORM_BUFFER, glBlockPointers.find(blockNdx) /*(glw::GLsizeiptr)glData.size(), &glData[0]*/, gl.STATIC_DRAW);

        // Bind ranges to binding points.
        for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
            binding = blockNdx;
            gl.bindBufferRange(gl.UNIFORM_BUFFER, binding, buffer, glBlockPointers.offsets[blockNdx], glLayout.blocks[blockNdx].size);
        }
    }

    /** @type {boolean} */ var renderOk = this.render(program);
    if (!renderOk)
        testFailedOptions('Image compare failed', false);
    else
        assertMsgOptions(renderOk, '', true, false);

    return tcuTestCase.IterateResult.STOP;
};

/**
* compareStd140Blocks
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareStd140Blocks = function(refLayout, cmpLayout) {
    /**@type {boolean} */ var isOk = true;
    /**@type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();

    for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
        /**@type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
        /**@type {boolean} */ var isArray = block.isArray();
        /**@type {string} */ var instanceName = block.getBlockName() + (isArray ? '[0]' : '');
        /**@type {number} */ var refBlockNdx = refLayout.getBlockIndex(instanceName);
        /**@type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);
        /**@type {boolean} */ var isUsed = (block.getFlags() & (glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) != 0;

        if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_STD140) == 0)
            continue; // Not std140 layout.

        DE_ASSERT(refBlockNdx >= 0);

        if (cmpBlockNdx < 0) {
            // Not found, should it?
            if (isUsed) {
                bufferedLogToConsole("Error: glsUniformBlockCase.Uniform block '" + instanceName + "' not found");
                isOk = false;
            }

            continue; // Skip block.
        }

        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var refBlockLayout = refLayout.blocks[refBlockNdx];
        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];

        // \todo [2012-01-24 pyry] Verify that activeUniformIndices is correct.
        // \todo [2012-01-24 pyry] Verify all instances.
        if (refBlockLayout.activeUniformIndices.length != cmpBlockLayout.activeUniformIndices.length) {
            bufferedLogToConsole("Error: Number of active uniforms differ in block '" + instanceName +
                "' (expected " + refBlockLayout.activeUniformIndices.length +
                ', got ' + cmpBlockLayout.activeUniformIndices.length +
                ')');
            isOk = false;
        }

        for (var ndx = 0; ndx < refBlockLayout.activeUniformIndices.length; ndx++) {
            /** @type {number} */ var ndxIter = refBlockLayout.activeUniformIndices[ndx];
            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[ndxIter];
            /** @type {number} */ var cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name);

            if (cmpEntryNdx < 0) {
                bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + refEntry.name + "' not found");
                isOk = false;
                continue;
            }

            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[cmpEntryNdx];

            if (refEntry.type != cmpEntry.type ||
                refEntry.size != cmpEntry.size ||
                refEntry.offset != cmpEntry.offset ||
                refEntry.arrayStride != cmpEntry.arrayStride ||
                refEntry.matrixStride != cmpEntry.matrixStride ||
                refEntry.isRowMajor != cmpEntry.isRowMajor) {
                bufferedLogToConsole("Error: Layout mismatch in '" + refEntry.name + "':\n" +
                ' expected: type = ' + gluShaderUtil.getDataTypeName(refEntry.type) + ', size = ' + refEntry.size + ', row major = ' + (refEntry.isRowMajor ? 'true' : 'false') + '\n' +
                ' got: type = ' + gluShaderUtil.getDataTypeName(cmpEntry.type) + ', size = ' + cmpEntry.size + ', row major = ' + (cmpEntry.isRowMajor ? 'true' : 'false'));
                isOk = false;
            }
        }
    }

    return isOk;
};

/**
* compareSharedBlocks
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareSharedBlocks = function(refLayout, cmpLayout) {
    /** @type {boolean} */ var isOk = true;
    /** @type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();

    for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
        /** @type {boolean} */ var isArray = block.isArray();
        /** @type {string} */ var instanceName = block.getBlockName() + (isArray ? '[0]' : '');
        /** @type {number} */ var refBlockNdx = refLayout.getBlockIndex(instanceName);
        /** @type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);
        /** @type {boolean} */ var isUsed = (block.getFlags() & (glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) != 0;

        if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_SHARED) == 0)
            continue; // Not shared layout.

        DE_ASSERT(refBlockNdx >= 0);

        if (cmpBlockNdx < 0) {
            // Not found, should it?
            if (isUsed) {
                bufferedLogToConsole("Error: glsUniformBlockCase.Uniform block '" + instanceName + "' not found");
                isOk = false;
            }

            continue; // Skip block.
        }

        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var refBlockLayout = refLayout.blocks[refBlockNdx];
        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];

        if (refBlockLayout.activeUniformIndices.length != cmpBlockLayout.activeUniformIndices.length) {
            bufferedLogToConsole("Error: Number of active uniforms differ in block '" + instanceName +
                "' (expected " + refBlockLayout.activeUniformIndices.length +
                ', got ' + cmpBlockLayout.activeUniformIndices.length +
                ')');
            isOk = false;
        }

        for (var ndx = 0; ndx < refBlockLayout.activeUniformIndices.length; ndx++) {
            /** @type {number} */ var ndxIter = refBlockLayout.activeUniformIndices[ndx];
            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[ndxIter];
            /** @type {number} */ var cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name);

            if (cmpEntryNdx < 0) {
                bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + refEntry.name + "' not found");
                isOk = false;
                continue;
            }

            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[cmpEntryNdx];

            if (refEntry.type != cmpEntry.type ||
                refEntry.size != cmpEntry.size ||
                refEntry.isRowMajor != cmpEntry.isRowMajor) {
                bufferedLogToConsole("Error: Layout mismatch in '" + refEntry.name + "':\n" +
                ' expected: type = ' + gluShaderUtil.getDataTypeName(refEntry.type) + ', size = ' + refEntry.size + ', row major = ' + (refEntry.isRowMajor ? 'true' : 'false') + '\n' +
                ' got: type = ' + gluShaderUtil.getDataTypeName(cmpEntry.type) + ', size = ' + cmpEntry.size + ', row major = ' + (cmpEntry.isRowMajor ? 'true' : 'false'));
                isOk = false;
            }
        }
    }

    return isOk;
};

/** compareTypes
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
* @return {boolean} true if uniform types are the same
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareTypes = function(refLayout, cmpLayout) {
    /** @type {boolean} */ var isOk = true;
    /** @type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();

    for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
        /** @type {boolean} */ var isArray = block.isArray();
        /** @type {number} */ var numInstances = isArray ? block.getArraySize() : 1;

        for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
            /** @type {string} */ var instanceName;

            instanceName += block.getBlockName();
            if (isArray)
                instanceName = instanceName + '[' + instanceNdx + ']';

            /** @type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);

            if (cmpBlockNdx < 0)
                continue;

            /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];

            for (var ndx = 0; ndx < cmpBlockLayout.activeUniformIndices.length; ndx++) {
                /** @type {number} */ var ndxIter = cmpBlockLayout.activeUniformIndices[ndx];
                /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[ndxIter];
                /** @type {number} */ var refEntryNdx = refLayout.getUniformIndex(cmpEntry.name);

                if (refEntryNdx < 0) {
                    bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + cmpEntry.name + "' not found in reference layout");
                    isOk = false;
                    continue;
                }

                /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[refEntryNdx];

                // \todo [2012-11-26 pyry] Should we check other properties as well?
                if (refEntry.type != cmpEntry.type) {
                    bufferedLogToConsole("Error: glsUniformBlockCase.Uniform type mismatch in '" + refEntry.name + "':</br>" +
                        "' expected: '" + gluShaderUtil.getDataTypeName(refEntry.type) + "'</br>" +
                        "' got: '" + gluShaderUtil.getDataTypeName(cmpEntry.type) + "'");
                    isOk = false;
                }
            }
        }
    }

    return isOk;
};

/** checkLayoutIndices
* @param {glsUniformBlockCase.UniformLayout} layout Layout whose indices are to be checked
* @return {boolean} true if all is ok
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkLayoutIndices = function(layout) {
    /** @type {number} */ var numUniforms = layout.uniforms.length;
    /** @type {number} */ var numBlocks = layout.blocks.length;
    /** @type {boolean} */ var isOk = true;

    // Check uniform block indices.
    for (var uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) {
        /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var uniform = layout.uniforms[uniformNdx];

        if (uniform.blockNdx < 0 || !deMath.deInBounds32(uniform.blockNdx, 0, numBlocks)) {
            bufferedLogToConsole("Error: Invalid block index in uniform '" + uniform.name + "'");
            isOk = false;
        }
    }

    // Check active uniforms.
    for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
        /** @type {glsUniformBlockCase.BlockLayoutEntry} */ var block = layout.blocks[blockNdx];

        for (var uniformNdx = 0; uniformNdx < block.activeUniformIndices.length; uniformNdx++) {
            /** @type {glsUniformBlockCase.UniformLayoutEntry} */ var activeUniformNdx = block.activeUniformIndices[uniformNdx];
            if (!deMath.deInBounds32(activeUniformNdx, 0, numUniforms)) {
                bufferedLogToConsole('Error: Invalid active uniform index ' + activeUniformNdx + " in block '" + block.name);
                isOk = false;
            }
        }
    }
    return isOk;
};

/** checkLayoutBounds
* @param {glsUniformBlockCase.UniformLayout} layout The uniform layout to check
* @return {boolean} true if all is within bounds
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkLayoutBounds = function(layout) {
    /** @type {number} */ var numUniforms = layout.uniforms.length;
    /** @type {boolean}*/ var isOk = true;

    for (var uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) {
        /** @type {glsUniformBlockCase.UniformLayoutEntry}*/ var uniform = layout.uniforms[uniformNdx];

        if (uniform.blockNdx < 0)
            continue;

        /** @type {glsUniformBlockCase.BlockLayoutEntry}*/ var block = layout.blocks[uniform.blockNdx];
        /** @type {boolean}*/ var isMatrix = gluShaderUtil.isDataTypeMatrix(uniform.type);
        /** @type {number}*/ var numVecs = isMatrix ? (uniform.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(uniform.type) : gluShaderUtil.getDataTypeMatrixNumColumns(uniform.type)) : 1;
        /** @type {number}*/ var numComps = isMatrix ? (uniform.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(uniform.type) : gluShaderUtil.getDataTypeMatrixNumRows(uniform.type)) : gluShaderUtil.getDataTypeScalarSize(uniform.type);
        /** @type {number}*/ var numElements = uniform.size;
        /** @type {number}*/ var compSize = deMath.INT32_SIZE;
        /** @type {number}*/ var vecSize = numComps * compSize;

        /** @type {number}*/ var minOffset = 0;
        /** @type {number}*/ var maxOffset = 0;

        // For negative strides.
        minOffset = Math.min(minOffset, (numVecs - 1) * uniform.matrixStride);
        minOffset = Math.min(minOffset, (numElements - 1) * uniform.arrayStride);
        minOffset = Math.min(minOffset, (numElements - 1) * uniform.arrayStride + (numVecs - 1) * uniform.matrixStride);

        maxOffset = Math.max(maxOffset, vecSize);
        maxOffset = Math.max(maxOffset, (numVecs - 1) * uniform.matrixStride + vecSize);
        maxOffset = Math.max(maxOffset, (numElements - 1) * uniform.arrayStride + vecSize);
        maxOffset = Math.max(maxOffset, (numElements - 1) * uniform.arrayStride + (numVecs - 1) * uniform.matrixStride + vecSize);

        if (uniform.offset + minOffset < 0 || uniform.offset + maxOffset > block.size) {
            bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + uniform.name + "' out of block bounds");
            isOk = false;
        }
    }

    return isOk;
};

/** checkIndexQueries
* @param {WebGLProgram} program The shader program to be checked against
* @param {glsUniformBlockCase.UniformLayout} layout The layout to check
* @return {boolean} true if everything matches.
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkIndexQueries = function(program, layout) {
    /** @type {boolean}*/ var allOk = true;

    // \note Spec mandates that uniform blocks are assigned consecutive locations from 0
    //       to ACTIVE_UNIFORM_BLOCKS. BlockLayoutEntries are stored in that order in glsUniformBlockCase.UniformLayout.
    for (var blockNdx = 0; blockNdx < layout.blocks.length; blockNdx++) {
        /** @const */ var block = layout.blocks[blockNdx];
        /** @const */ var queriedNdx = gl.getUniformBlockIndex(program, block.name);

        if (queriedNdx != blockNdx) {
            bufferedLogToConsole('ERROR: glGetUniformBlockIndex(' + block.name + ') returned ' + queriedNdx + ', expected ' + blockNdx + '!');
            allOk = false;
        }
    }

    return allOk;
};

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

/** Renders a white square, and then tests all pixels are
* effectively white in the color buffer.
* @param {gluShaderProgram.ShaderProgram} program The shader program to use.
* @return {boolean} false if there was at least one incorrect pixel
**/
glsUniformBlockCase.UniformBlockCase.prototype.render = function(program) {
    // Compute viewport.
    /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name));
    /** @const */ var viewportW = Math.min(gl.canvas.width, glsUniformBlockCase.VIEWPORT_WIDTH);
    /** @const */ var viewportH = Math.min(gl.canvas.height, glsUniformBlockCase.VIEWPORT_HEIGHT);
    /** @const */ var viewportX = rnd.getInt(0, gl.canvas.width);
    /** @const */ var viewportY = rnd.getInt(0, gl.canvas.height);

    gl.clearColor(0.125, 0.25, 0.5, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);

    //Draw
    var position = [
        -1.0, -1.0, 0.0, 1.0,
        -1.0, 1.0, 0.0, 1.0,
        1.0, -1.0, 0.0, 1.0,
        1.0, 1.0, 0.0, 1.0
        ];
    var indices = [0, 1, 2, 2, 1, 3];

    gl.viewport(viewportX, viewportY, viewportW, viewportH);

    // Access
    var posLoc = gl.getAttribLocation(program.getProgram(), 'a_position');
    var posArray = [new gluDrawUtil.VertexArrayBinding(gl.FLOAT, posLoc, 4, 4, position)];
    gluDrawUtil.draw(gl, program.getProgram(), posArray, gluDrawUtil.triangles(indices));

    // Verify that all pixels are white.
    var pixels = new gluDrawUtil.Surface();
    var numFailedPixels = 0;

    var readPixelsX = (viewportX + viewportW) > gl.canvas.width
        ? (gl.canvas.width - viewportX) : viewportW;
    var readPixelsY = (viewportY + viewportH) > gl.canvas.height
        ? (gl.canvas.height - viewportY) : viewportH;

    var buffer = pixels.readSurface(gl, viewportX, viewportY, readPixelsX, readPixelsY);

    var whitePixel = new gluDrawUtil.Pixel([255.0, 255.0, 255.0, 255.0]);
    for (var y = 0; y < readPixelsY; y++) {
        for (var x = 0; x < readPixelsX; x++) {
            if (!pixels.getPixel(x, y).equals(whitePixel))
                numFailedPixels += 1;
        }
    }

    if (numFailedPixels > 0) {
        bufferedLogToConsole('Image comparison failed, got ' + numFailedPixels + ' non-white pixels.');
    }

    return numFailedPixels == 0;
};

});