LayoutTests/webgl/resources/webgl_test_files/deqp/functional/gles3/es3fShaderStateQueryTests.js

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the 'License');
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an 'AS IS' BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

'use strict';
goog.provide('functional.gles3.es3fShaderStateQueryTests');
goog.require('framework.common.tcuMatrix');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deRandom');
goog.require('functional.gles3.es3fApiCase');
goog.require('modules.shared.glsStateQuery');

goog.scope(function() {
var es3fShaderStateQueryTests = functional.gles3.es3fShaderStateQueryTests;
var tcuTestCase = framework.common.tcuTestCase;
var glsStateQuery = modules.shared.glsStateQuery;
var es3fApiCase = functional.gles3.es3fApiCase;
var deRandom = framework.delibs.debase.deRandom;
var tcuMatrix = framework.common.tcuMatrix;

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

var commonTestVertSource = '#version 300 es\n' +
                            'void main (void)\n' +
                            '{\n' +
                            ' gl_Position = vec4(0.0);\n' +
                            '}\n';
var commonTestFragSource = '#version 300 es\n' +
                            'layout(location = 0) out mediump vec4 fragColor;\n' +
                            'void main (void)\n' +
                            '{\n' +
                            ' fragColor = vec4(0.0);\n' +
                            '}\n';

var brokenShader = '#version 300 es\n' +
                            'broken, this should not compile!\n' +
                            '\n';

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ShaderTypeCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ShaderTypeCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ShaderTypeCase.prototype.test = function() {
    var shaderTypes = [gl.VERTEX_SHADER, gl.FRAGMENT_SHADER];
    for (var ndx = 0; ndx < shaderTypes.length; ++ndx) {
        var shader = gl.createShader(shaderTypes[ndx]);
        var result = glsStateQuery.verifyShader(shader, gl.SHADER_TYPE, shaderTypes[ndx]);
        this.check(result, 'Incorrect shader type');
        gl.deleteShader(shader);
    }
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ShaderCompileStatusCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ShaderCompileStatusCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ShaderCompileStatusCase.prototype.test = function() {
    var result;
    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    result = glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, false);
    this.check(result, 'Vertex shader compilation status should be false');
    result = glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, false);
    this.check(result, 'Fragment shader compilation status should be false');

    gl.shaderSource(shaderVert, commonTestVertSource);
    gl.shaderSource(shaderFrag, commonTestFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    result = glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true);
    this.check(result, 'Vertex shader compilation status should be true');
    result = glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true);
    this.check(result, 'Fragment shader compilation status should be true');

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ShaderInfoLogCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ShaderInfoLogCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ShaderInfoLogCase.prototype.test = function() {
    var shader = gl.createShader(gl.VERTEX_SHADER);
    var log = gl.getShaderInfoLog(shader);
    this.check(log === '');

    gl.shaderSource(shader, brokenShader);
    gl.compileShader(shader);

    log = gl.getShaderInfoLog(shader);
    this.check(log === null || typeof log === 'string');

    gl.deleteShader(shader);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ShaderSourceCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ShaderSourceCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ShaderSourceCase.prototype.test = function() {
    var shader = gl.createShader(gl.VERTEX_SHADER);
    this.check(gl.getShaderSource(shader) === '');

    gl.shaderSource(shader, brokenShader);
    this.check(gl.getShaderSource(shader) === brokenShader);

    gl.deleteShader(shader);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.DeleteStatusCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.DeleteStatusCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.DeleteStatusCase.prototype.test = function() {
    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, commonTestVertSource);
    gl.shaderSource(shaderFrag, commonTestFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true));

    var shaderProg = gl.createProgram();
    gl.attachShader(shaderProg, shaderVert);
    gl.attachShader(shaderProg, shaderFrag);
    gl.linkProgram(shaderProg);

    this.check(glsStateQuery.verifyProgram(shaderProg, gl.LINK_STATUS, true));

    this.check(glsStateQuery.verifyShader(shaderVert, gl.DELETE_STATUS, false));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.DELETE_STATUS, false));
    this.check(glsStateQuery.verifyProgram(shaderProg, gl.DELETE_STATUS, false));

    gl.useProgram(shaderProg);

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(shaderProg);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.DELETE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.DELETE_STATUS, true));
    this.check(glsStateQuery.verifyProgram(shaderProg, gl.DELETE_STATUS, true));

    gl.useProgram(null);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.CurrentVertexAttribInitialCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribInitialCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.CurrentVertexAttribInitialCase.prototype.test = function() {
    var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
    var initial = new Float32Array([0, 0, 0, 1]);
    // initial

    for (var index = 0; index < attribute_count; ++index) {
        var attrib = gl.getVertexAttrib(index, gl.CURRENT_VERTEX_ATTRIB);
        this.check(glsStateQuery.compare(attrib, initial), 'Initial attrib value should be [0, 0, 0, 1]');
    }
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.CurrentVertexAttribFloatCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribFloatCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.CurrentVertexAttribFloatCase.prototype.test = function() {
    var rnd = new deRandom.Random(0xabcdef);

    var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));

    // test write float/read float

    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getFloat(-64000, 64000);
        var y = rnd.getFloat(-64000, 64000);
        var z = rnd.getFloat(-64000, 64000);
        var w = rnd.getFloat(-64000, 64000);

        gl.vertexAttrib4f(index, x, y, z, w);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w])));
    }
    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getFloat(-64000, 64000);
        var y = rnd.getFloat(-64000, 64000);
        var z = rnd.getFloat(-64000, 64000);
        var w = 1.0;

        gl.vertexAttrib3f(index, x, y, z);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w])));
    }
    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getFloat(-64000, 64000);
        var y = rnd.getFloat(-64000, 64000);
        var z = 0.0;
        var w = 1.0;

        gl.vertexAttrib2f(index, x, y);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w])));
    }
    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getFloat(-64000, 64000);
        var y = 0.0;
        var z = 0.0;
        var w = 1.0;

        gl.vertexAttrib1f(index, x);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w])));
    }
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.CurrentVertexAttribIntCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribIntCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.CurrentVertexAttribIntCase.prototype.test = function() {
    var rnd = new deRandom.Random(0xabcdef);

    var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));

    // test write float/read float

    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getInt(-64000, 64000);
        var y = rnd.getInt(-64000, 64000);
        var z = rnd.getInt(-64000, 64000);
        var w = rnd.getInt(-64000, 64000);

        gl.vertexAttribI4i(index, x, y, z, w);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Int32Array([x, y, z, w])));
    }
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.CurrentVertexAttribUintCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribUintCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.CurrentVertexAttribUintCase.prototype.test = function() {
    var rnd = new deRandom.Random(0xabcdef);

    var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));

    // test write float/read float

    for (var index = 0; index < attribute_count; ++index) {
        var x = rnd.getInt(0, 64000);
        var y = rnd.getInt(0, 64000);
        var z = rnd.getInt(0, 64000);
        var w = rnd.getInt(0, 64000);

        gl.vertexAttribI4ui(index, x, y, z, w);
        this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Uint32Array([x, y, z, w])));
    }
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramInfoLogCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramInfoLogCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramInfoLogCase.prototype.test = function() {
    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, brokenShader);
    gl.compileShader(shaderVert);
    gl.shaderSource(shaderFrag, brokenShader);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    var log = gl.getProgramInfoLog(program);
    this.check(log === null || typeof log === 'string');

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramValidateStatusCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramValidateStatusCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramValidateStatusCase.prototype.test = function() {
    // test validate ok
    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, commonTestVertSource);
    gl.shaderSource(shaderFrag, commonTestFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true));

    gl.validateProgram(program);
    this.check(glsStateQuery.verifyProgram(program, gl.VALIDATE_STATUS, true));

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);

    // test with broken shader
    shaderVert = gl.createShader(gl.VERTEX_SHADER);
    shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, commonTestVertSource);
    gl.shaderSource(shaderFrag, brokenShader);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, false));
    this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, false));

    gl.validateProgram(program);
    this.check(glsStateQuery.verifyProgram(program, gl.VALIDATE_STATUS, false));

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramAttachedShadersCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramAttachedShadersCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramAttachedShadersCase.prototype.test = function() {
    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, commonTestVertSource);
    gl.shaderSource(shaderFrag, commonTestFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    // check ATTACHED_SHADERS

    var program = gl.createProgram();
    this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 0));

    gl.attachShader(program, shaderVert);
    this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 1));

    gl.attachShader(program, shaderFrag);
    this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 2));

    // check GetAttachedShaders
    var shaders = gl.getAttachedShaders(program);
    this.check(glsStateQuery.compare(shaders, [shaderVert, shaderFrag]));

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramActiveUniformNameCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramActiveUniformNameCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramActiveUniformNameCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform highp float uniformNameWithLength23;\n' +
        'uniform highp vec2 uniformVec2;\n' +
        'uniform highp mat4 uniformMat4;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(0.0) + vec4(uniformNameWithLength23) + vec4(uniformVec2.x) + vec4(uniformMat4[2][3]);\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_UNIFORMS, 3));

    var uniformNames = [
        'uniformNameWithLength23',
        'uniformVec2',
        'uniformMat4'
    ];

    var indices = gl.getUniformIndices(program, uniformNames);

    // check names
    for (var ndx = 0; ndx < uniformNames.length; ++ndx) {
        var index = indices[ndx];
        var uniform = gl.getActiveUniform(program, index);

        this.check(glsStateQuery.compare(uniform.name, uniformNames[ndx]));
    }

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);

};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramUniformCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramUniformCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramUniformCase.prototype.test = function() {
    var uniformTypes = [
        ['float', '', 'highp', '', 'uniformValue', gl.FLOAT, 1, false],
        ['float[2]', '', 'highp', '', 'uniformValue[1]', gl.FLOAT, 2, false],
        ['vec2', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC2, 1, false],
        ['vec3', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC3, 1, false],
        ['vec4', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC4, 1, false],
        ['int', '', 'highp', '', 'float(uniformValue)', gl.INT, 1, false],
        ['ivec2', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC2, 1, false],
        ['ivec3', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC3, 1, false],
        ['ivec4', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC4, 1, false],
        ['uint', '', 'highp', '', 'float(uniformValue)', gl.UNSIGNED_INT, 1, false],
        ['uvec2', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC2, 1, false],
        ['uvec3', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC3, 1, false],
        ['uvec4', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC4, 1, false],
        ['bool', '', '', '', 'float(uniformValue)', gl.BOOL, 1, false],
        ['bvec2', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC2, 1, false],
        ['bvec3', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC3, 1, false],
        ['bvec4', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC4, 1, false],
        ['mat2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2, 1, false],
        ['mat3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3, 1, false],
        ['mat4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4, 1, false],
        ['mat2x3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2x3, 1, false],
        ['mat2x4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2x4, 1, false],
        ['mat3x2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3x2, 1, false],
        ['mat3x4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3x4, 1, false],
        ['mat4x2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4x2, 1, false],
        ['mat4x3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4x3, 1, false],
        ['sampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D, 1, false],
        ['sampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_3D, 1, false],
        ['samplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_CUBE, 1, false],
        ['sampler2DShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_SHADOW, 1, false],
        ['sampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_ARRAY, 1, false],
        ['sampler2DArrayShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_ARRAY_SHADOW, 1, false],
        ['samplerCubeShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_CUBE_SHADOW, 1, false],
        ['isampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_2D, 1, false],
        ['isampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_3D, 1, false],
        ['isamplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_CUBE, 1, false],
        ['isampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_2D_ARRAY, 1, false],
        ['usampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_2D, 1, false],
        ['usampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_3D, 1, false],
        ['usamplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_CUBE, 1, false],
        ['usampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_2D_ARRAY, 1, false]
    ];

    var vertSource =
        '#version 300 es\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);
    var program = gl.createProgram();

    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);

    gl.shaderSource(shaderVert, vertSource);
    gl.compileShader(shaderVert);

    for (var ndx = 0; ndx < uniformTypes.length; ++ndx) {
        var declaration = uniformTypes[ndx][0];
        var postDeclaration = uniformTypes[ndx][1];
        var precision = uniformTypes[ndx][2];
        var layout = uniformTypes[ndx][3];
        var getter = uniformTypes[ndx][4];
        var type = uniformTypes[ndx][5];
        var size = uniformTypes[ndx][6];
        var isRowMajor = uniformTypes[ndx][7];
        bufferedLogToConsole('Verify type of ' + declaration + ' variable' + postDeclaration);

        // gen fragment shader

        var frag = '';
        frag += '#version 300 es\n';
        frag += layout + 'uniform ' + precision + ' ' + declaration + ' uniformValue' + postDeclaration + ';\n';
        frag += 'layout(location = 0) out mediump vec4 fragColor;\n';
        frag += 'void main (void)\n';
        frag += '{\n';
        frag += ' fragColor = vec4(' + getter + ');\n';
        frag += '}\n';

        gl.shaderSource(shaderFrag, frag);

        // compile & link

        gl.compileShader(shaderFrag);
        gl.linkProgram(program);

        // test
        if (this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true), 'Program link fail' + gl.getProgramInfoLog(program))) {
            var indices = gl.getUniformIndices(program, ['uniformValue']);
            var info_type = gl.getActiveUniforms(program, indices, gl.UNIFORM_TYPE)[0];
            var info_size = gl.getActiveUniforms(program, indices, gl.UNIFORM_SIZE)[0];
            var info_is_row_major = gl.getActiveUniforms(program, indices, gl.UNIFORM_IS_ROW_MAJOR)[0];
            this.check(glsStateQuery.compare(info_size, size));
            this.check(glsStateQuery.compare(info_type, type));
            this.check(glsStateQuery.compare(info_is_row_major, isRowMajor));
        }
    }

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n' +
        'uniform shortUniformBlockName {highp vec2 vector2;highp vec4 vector4;} shortUniformInstanceName;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = shortUniformInstanceName.vector4 + vec4(longlongUniformInstanceName.vector2.x) + vec4(shortUniformInstanceName.vector2.x);\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(longlongUniformInstanceName.vector2.y);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true));

    this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_UNIFORM_BLOCKS, 2));

    var longlongUniformBlockIndex = gl.getUniformBlockIndex(program, 'longlongUniformBlockName');
    var shortUniformBlockIndex = gl.getUniformBlockIndex(program, 'shortUniformBlockName');

    var uniformNames = [
        'longlongUniformBlockName.vector2',
        'shortUniformBlockName.vector2',
        'shortUniformBlockName.vector4'
    ];

    // test UNIFORM_BLOCK_INDEX

    var uniformIndices = gl.getUniformIndices(program, uniformNames);

    var uniformsBlockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX);
    this.check(uniformsBlockIndices[0] == longlongUniformBlockIndex &&
        uniformsBlockIndices[1] == shortUniformBlockIndex &&
        uniformsBlockIndices[2] == shortUniformBlockIndex,
        'Expected [' + longlongUniformBlockIndex + ", " + shortUniformBlockIndex + ", " + shortUniformBlockIndex + ']; got ' +
        uniformsBlockIndices[0] + ", " + uniformsBlockIndices[1] + ", " + uniformsBlockIndices[2] + "]");

    // test UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER & UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER

    this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, true));
    this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, true));
    this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, true));
    this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, false));

    // test UNIFORM_BLOCK_ACTIVE_UNIFORMS

    this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, 1));
    this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, 2));

    // test UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES

    var shortUniformBlockIndices = gl.getActiveUniformBlockParameter(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
    this.check(shortUniformBlockIndices.length == 2, 'Expected 2 indices; got ' + shortUniformBlockIndices.length);

    this.check(glsStateQuery.compare(shortUniformBlockIndices, new Uint32Array([uniformIndices[1], uniformIndices[2]])) ||
               glsStateQuery.compare(shortUniformBlockIndices, new Uint32Array([uniformIndices[2], uniformIndices[1]])),
                'Expected { ' + uniformIndices[1] +', ' + uniformIndices[2] +
                '}; got {' + shortUniformBlockIndices[0] + ', ' + shortUniformBlockIndices[1] + '}');

    // check block names

    var name = gl.getActiveUniformBlockName(program, longlongUniformBlockIndex);
    this.check(name == "longlongUniformBlockName", 'Wrong uniform block name, expected longlongUniformBlockName; got ' + name);
    name = gl.getActiveUniformBlockName(program, shortUniformBlockIndex)
    this.check(name == "shortUniformBlockName", 'Wrong uniform block name, expected shortUniformBlockName; got ' + name);

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.TransformFeedbackCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.TransformFeedbackCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.TransformFeedbackCase.prototype.test = function() {
    var transformFeedbackTestVertSource =
        '#version 300 es\n' +
        'out highp vec4 tfOutput2withLongName;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(0.0);\n' +
        ' tfOutput2withLongName = vec4(0.0);\n' +
        '}\n';
    var transformFeedbackTestFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out highp vec4 fragColor;\n' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);
    var shaderProg = gl.createProgram();

    this.check(glsStateQuery.verifyProgram(shaderProg, gl.TRANSFORM_FEEDBACK_BUFFER_MODE, gl.INTERLEAVED_ATTRIBS));

    gl.shaderSource(shaderVert, transformFeedbackTestVertSource);
    gl.shaderSource(shaderFrag, transformFeedbackTestFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true));
    this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true));

    gl.attachShader(shaderProg, shaderVert);
    gl.attachShader(shaderProg, shaderFrag);

    // check TRANSFORM_FEEDBACK_BUFFER_MODE

    var transform_feedback_outputs = ['gl_Position', 'tfOutput2withLongName'];
    var bufferModes = [gl.SEPARATE_ATTRIBS, gl.INTERLEAVED_ATTRIBS];

    for (var ndx = 0; ndx < bufferModes.length; ++ndx) {
        gl.transformFeedbackVaryings(shaderProg, transform_feedback_outputs, bufferModes[ndx]);
        gl.linkProgram(shaderProg);

        this.check(glsStateQuery.verifyProgram(shaderProg, gl.LINK_STATUS, true));
        this.check(glsStateQuery.verifyProgram(shaderProg, gl.TRANSFORM_FEEDBACK_BUFFER_MODE, bufferModes[ndx]));
    }

    // check varyings
    var varyings = /** @type {number} */ (gl.getProgramParameter(shaderProg, gl.TRANSFORM_FEEDBACK_VARYINGS));
    this.check(varyings === 2);

    for (var index = 0; index < varyings; ++index) {
        var info = gl.getTransformFeedbackVarying(shaderProg, index);
        this.check(glsStateQuery.compare(info.type, gl.FLOAT_VEC4));
        this.check(glsStateQuery.compare(info.size, 1));
        this.check(glsStateQuery.compare(info.name, transform_feedback_outputs[index]));
    }

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(shaderProg);

    // TODO(kbr): this test is failing and leaving an error in the GL
    // state, causing later tests to fail. Clear the error state for
    // the time being.
    while (gl.getError() != gl.NO_ERROR) {}
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.ActiveAttributesCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.ActiveAttributesCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.ActiveAttributesCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'in highp vec2 longInputAttributeName;\n' +
        'in highp vec2 shortName;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = longInputAttributeName.yxxy + shortName.xyxy;\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);

    this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_ATTRIBUTES, 2));

    var attribNames = [
        'longInputAttributeName',
        'shortName'
    ];
    // check names
    for (var attributeNdx = 0; attributeNdx < 2; ++attributeNdx) {
        var info = gl.getActiveAttrib(program, attributeNdx);
        this.check(glsStateQuery.compare(info.name, attribNames[0]) || glsStateQuery.compare(info.name, attribNames[1]));
    }

    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeSizeCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeSizeCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeSizeCase.prototype.test = function() {
    var pointers = [
        // size test
        [4, gl.FLOAT, 0, false, 0],
        [3, gl.FLOAT, 0, false, 0],
        [2, gl.FLOAT, 0, false, 0],
        [1, gl.FLOAT, 0, false, 0],
        [4, gl.INT, 0, false, 0],
        [3, gl.INT, 0, false, 0],
        [2, gl.INT, 0, false, 0],
        [1, gl.INT, 0, false, 0]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[ndx][0]));
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, 4));

    // set vao 0 to some value
    gl.vertexAttribPointer(0, pointers[0][0], pointers[0][1], pointers[0][3], pointers[0][2], 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, pointers[1][0], pointers[1][1], pointers[1][3], pointers[1][2], 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[1][0]));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[0][0]));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeTypeCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeTypeCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeTypeCase.prototype.test = function() {
    var pointers = [
        // type test
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.FLOAT, 0, false, 0],
        [1, gl.HALF_FLOAT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0],
        [4, gl.INT_2_10_10_10_REV, 0, false, 0],
        [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, pointers[ndx][1]));
    }

    var pointersI = [
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0]
    ];

    for (var ndx = 0; ndx < pointersI.length; ++ndx) {
        gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, pointersI[ndx][1]));
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.FLOAT));

    // set vao 0 to some value
    gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, 1, gl.SHORT, false, 0, 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.SHORT));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.FLOAT));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeStrideCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeStrideCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeStrideCase.prototype.test = function() {
    var pointers = [
        [1, gl.FLOAT, 0, 0, gl.NO_ERROR],
        [1, gl.FLOAT, 1, 0, gl.INVALID_OPERATION],
        [1, gl.FLOAT, 4, 0, gl.NO_ERROR],
        [1, gl.HALF_FLOAT, 0, 0, gl.NO_ERROR],
        [1, gl.HALF_FLOAT, 1, 0, gl.INVALID_OPERATION],
        [1, gl.HALF_FLOAT, 4, 0, gl.NO_ERROR]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], false, pointers[ndx][2], pointers[ndx][3]);
        this.expectError(pointers[ndx][4]);
        if (pointers[ndx][4] == gl.NO_ERROR) {
            this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, pointers[ndx][2]));
        }
    }

    var pointersI = [
        [1, gl.INT, 0, 0, gl.NO_ERROR],
        [1, gl.INT, 1, 0, gl.INVALID_OPERATION],
        [1, gl.INT, 4, 0, gl.NO_ERROR],
        [4, gl.UNSIGNED_BYTE, 0, 0, gl.NO_ERROR],
        [4, gl.UNSIGNED_BYTE, 1, 0, gl.NO_ERROR],
        [4, gl.UNSIGNED_BYTE, 4, 0, gl.NO_ERROR],
        [2, gl.SHORT, 0, 0, gl.NO_ERROR],
        [2, gl.SHORT, 1, 0, gl.INVALID_OPERATION],
        [2, gl.SHORT, 4, 0, gl.NO_ERROR]
    ];

    for (var ndx = 0; ndx < pointersI.length; ++ndx) {
        gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][3]);
        this.expectError(pointersI[ndx][4]);
        if (pointersI[ndx][4] == gl.NO_ERROR) {
            this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, pointersI[ndx][2]));
        }
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 0));

    // set vao 0 to some value
    gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 4, 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, 1, gl.SHORT, false, 8, 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 8));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 4));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeNormalizedCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeNormalizedCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeNormalizedCase.prototype.test = function() {
    var pointers = [
        // type test
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.FLOAT, 0, false, 0],
        [1, gl.HALF_FLOAT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0],
        [4, gl.INT_2_10_10_10_REV, 0, false, 0],
        [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0],
        [1, gl.BYTE, 0, true, 0],
        [1, gl.SHORT, 0, true, 0],
        [1, gl.INT, 0, true, 0],
        [1, gl.FLOAT, 0, true, 0],
        [1, gl.HALF_FLOAT, 0, true, 0],
        [1, gl.UNSIGNED_BYTE, 0, true, 0],
        [1, gl.UNSIGNED_SHORT, 0, true, 0],
        [1, gl.UNSIGNED_INT, 0, true, 0],
        [4, gl.INT_2_10_10_10_REV, 0, true, 0],
        [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, true, 0]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, pointers[ndx][3]));
    }

    var pointersI = [
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0]
    ];

    for (var ndx = 0; ndx < pointersI.length; ++ndx) {
        gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false));
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false));

    // set vao 0 to some value
    gl.vertexAttribPointer(0, 1, gl.INT, true, 0, 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, 1, gl.INT, false, 0, 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, true));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeIntegerCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeIntegerCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeIntegerCase.prototype.test = function() {
    var pointers = [
        // type test
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.FLOAT, 0, false, 0],
        [1, gl.HALF_FLOAT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0],
        [4, gl.INT_2_10_10_10_REV, 0, false, 0],
        [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false));
    }

    var pointersI = [
        [1, gl.BYTE, 0, false, 0],
        [1, gl.SHORT, 0, false, 0],
        [1, gl.INT, 0, false, 0],
        [1, gl.UNSIGNED_BYTE, 0, false, 0],
        [1, gl.UNSIGNED_SHORT, 0, false, 0],
        [1, gl.UNSIGNED_INT, 0, false, 0]
    ];

    for (var ndx = 0; ndx < pointersI.length; ++ndx) {
        gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, true));
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false));

    // set vao 0 to some value
    gl.vertexAttribIPointer(0, 1, gl.INT, 0, 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, true));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeEnabledCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeEnabledCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeEnabledCase.prototype.test = function() {
    // Test with default VAO

    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false));
    gl.enableVertexAttribArray(0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, true));
    gl.disableVertexAttribArray(0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false));

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    // set vao 0 to some value
    gl.enableVertexAttribArray(0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.disableVertexAttribArray(0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, true));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeDivisorCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeDivisorCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeDivisorCase.prototype.test = function() {
    // Test with default VAO

    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 0));
    gl.vertexAttribDivisor(0, 1);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 1));
    gl.vertexAttribDivisor(0, 5);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 5));

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    // set vao 0 to some value
    gl.vertexAttribDivisor(0, 1);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribDivisor(0, 5);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 5));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 1));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeBufferBindingCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeBufferBindingCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeBufferBindingCase.prototype.test = function() {
    // Test with default VAO

    var buffer = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);

    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0);

    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer));

    gl.deleteBuffer(buffer);

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();
    var buffer0 = gl.createBuffer();
    var buffer1 = gl.createBuffer();

    // initial
    gl.bindVertexArray(vao0);
    // set vao 0 to some value
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer0);
    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer1);
    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer1));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer0));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buffer0);
    gl.deleteBuffer(buffer1);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.VertexAttributeOffsetCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.VertexAttributeOffsetCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.VertexAttributeOffsetCase.prototype.test = function() {
    var pointers = [
        [1, gl.BYTE, 0, false, 2 * 4],
        [1, gl.SHORT, 0, false, 1 * 4],
        [1, gl.INT, 0, false, 2 * 4],
        [1, gl.FLOAT, 0, false, 0 * 4],
        [1, gl.FLOAT, 0, false, 3 * 4],
        [1, gl.FLOAT, 0, false, 2 * 4],
        [1, gl.HALF_FLOAT, 0, false, 0 * 4],
        [4, gl.HALF_FLOAT, 0, false, 1 * 4],
        [4, gl.HALF_FLOAT, 0, false, 2 * 4]
    ];

    var buf = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, buf);

    // Test with default VAO

    for (var ndx = 0; ndx < pointers.length; ++ndx) {
        gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]);
        this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, pointers[ndx][4]));
    }

    // Test with multiple VAOs
    var vao0 = gl.createVertexArray();
    var vao1 = gl.createVertexArray();

    // initial
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 0));

    // set vao 0 to some value
    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 8);

    // set vao 1 to some other value
    gl.bindVertexArray(vao1);
    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 4);

    // verify vao 1 state
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 4));

    // verify vao 0 state
    gl.bindVertexArray(vao0);
    this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 8));

    gl.deleteVertexArray(vao0);
    gl.deleteVertexArray(vao1);
    gl.deleteBuffer(buf);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueFloatCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueFloatCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueFloatCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform highp float floatUniform;\n' +
        'uniform highp vec2 float2Uniform;\n' +
        'uniform highp vec3 float3Uniform;\n' +
        'uniform highp vec4 float4Uniform;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(floatUniform + float2Uniform.x + float3Uniform.x + float4Uniform.x);\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    location = gl.getUniformLocation(program, 'floatUniform');
    gl.uniform1f(location, 1);
    this.check(glsStateQuery.verifyUniform(program, location, 1));

    location = gl.getUniformLocation(program, 'float2Uniform');
    gl.uniform2f(location, 1, 2);
    this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2])));

    location = gl.getUniformLocation(program, 'float3Uniform');
    gl.uniform3f(location, 1, 2, 3);
    this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2, 3])));

    location = gl.getUniformLocation(program, 'float4Uniform');
    gl.uniform4f(location, 1, 2, 3, 4);
    this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2, 3, 4])));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueIntCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueIntCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueIntCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform highp int intUniform;\n' +
        'uniform highp ivec2 int2Uniform;\n' +
        'uniform highp ivec3 int3Uniform;\n' +
        'uniform highp ivec4 int4Uniform;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(float(intUniform + int2Uniform.x + int3Uniform.x + int4Uniform.x));\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    location = gl.getUniformLocation(program, 'intUniform');
    gl.uniform1i(location, 1);
    this.check(glsStateQuery.verifyUniform(program, location, 1));

    location = gl.getUniformLocation(program, 'int2Uniform');
    gl.uniform2i(location, 1, 2);
    this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2])));

    location = gl.getUniformLocation(program, 'int3Uniform');
    gl.uniform3i(location, 1, 2, 3);
    this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2, 3])));

    location = gl.getUniformLocation(program, 'int4Uniform');
    gl.uniform4i(location, 1, 2, 3, 4);
    this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2, 3, 4])));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueUintCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueUintCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueUintCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform highp uint uintUniform;\n' +
        'uniform highp uvec2 uint2Uniform;\n' +
        'uniform highp uvec3 uint3Uniform;\n' +
        'uniform highp uvec4 uint4Uniform;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(float(uintUniform + uint2Uniform.x + uint3Uniform.x + uint4Uniform.x));\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    location = gl.getUniformLocation(program, 'uintUniform');
    gl.uniform1ui(location, 1);
    this.check(glsStateQuery.verifyUniform(program, location, 1));

    location = gl.getUniformLocation(program, 'uint2Uniform');
    gl.uniform2ui(location, 1, 2);
    this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2])));

    location = gl.getUniformLocation(program, 'uint3Uniform');
    gl.uniform3ui(location, 1, 2, 3);
    this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2, 3])));

    location = gl.getUniformLocation(program, 'uint4Uniform');
    gl.uniform4ui(location, 1, 2, 3, 4);
    this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2, 3, 4])));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueBooleanCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueBooleanCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueBooleanCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform bool boolUniform;\n' +
        'uniform bvec2 bool2Uniform;\n' +
        'uniform bvec3 bool3Uniform;\n' +
        'uniform bvec4 bool4Uniform;\n' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(float(boolUniform) + float(bool2Uniform.x) + float(bool3Uniform.x) + float(bool4Uniform.x));\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    location = gl.getUniformLocation(program, 'boolUniform');
    gl.uniform1i(location, 1);
    this.check(glsStateQuery.verifyUniform(program, location, true));

    location = gl.getUniformLocation(program, 'bool2Uniform');
    gl.uniform2i(location, 1, 0);
    this.check(glsStateQuery.verifyUniform(program, location, [true, false]));

    location = gl.getUniformLocation(program, 'bool3Uniform');
    gl.uniform3i(location, 1, 0, 1);
    this.check(glsStateQuery.verifyUniform(program, location, [true, false, true]));

    location = gl.getUniformLocation(program, 'bool4Uniform');
    gl.uniform4i(location, 1, 0, 1, 0);
    this.check(glsStateQuery.verifyUniform(program, location, [true, false, true, false]));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueSamplerCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueSamplerCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueSamplerCase.prototype.test = function() {
        var testVertSource =
            '#version 300 es\n' +
            'void main (void)\n' +
            '{\n' +
            ' gl_Position = vec4(0.0);\n' +
            '}\n';
        var testFragSource =
            '#version 300 es\n' +
            'uniform highp sampler2D uniformSampler;\n' +
            'layout(location = 0) out mediump vec4 fragColor;' +
            'void main (void)\n' +
            '{\n' +
            ' fragColor = vec4(textureSize(uniformSampler, 0).x);\n' +
            '}\n';

        var shaderVert = gl.createShader(gl.VERTEX_SHADER);
        var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

        gl.shaderSource(shaderVert, testVertSource);
        gl.shaderSource(shaderFrag, testFragSource);

        gl.compileShader(shaderVert);
        gl.compileShader(shaderFrag);

        var program = gl.createProgram();
        gl.attachShader(program, shaderVert);
        gl.attachShader(program, shaderFrag);
        gl.linkProgram(program);
        gl.useProgram(program);

        var location;

        location = gl.getUniformLocation(program, 'uniformSampler');
        gl.uniform1i(location, 1);
        this.check(glsStateQuery.verifyUniform(program, location, 1));

        gl.useProgram(null);
        gl.deleteShader(shaderVert);
        gl.deleteShader(shaderFrag);
        gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueArrayCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueArrayCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueArrayCase.prototype.test = function() {
    var testVertSource =
        '#version 300 es\n' +
        'uniform highp float arrayUniform[5];' +
        'uniform highp vec2 array2Uniform[5];' +
        'uniform highp vec3 array3Uniform[5];' +
        'uniform highp vec4 array4Uniform[5];' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = \n' +
        ' + vec4(arrayUniform[0] + arrayUniform[1] + arrayUniform[2] + arrayUniform[3] + arrayUniform[4])\n' +
        ' + vec4(array2Uniform[0].x + array2Uniform[1].x + array2Uniform[2].x + array2Uniform[3].x + array2Uniform[4].x)\n' +
        ' + vec4(array3Uniform[0].x + array3Uniform[1].x + array3Uniform[2].x + array3Uniform[3].x + array3Uniform[4].x)\n' +
        ' + vec4(array4Uniform[0].x + array4Uniform[1].x + array4Uniform[2].x + array4Uniform[3].x + array4Uniform[4].x);\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    var uniformValue = [
        -1.0, 0.1, 4.0, 800.0,
        13.0, 55.0, 12.0, 91.0,
        -55.1, 1.1, 98.0, 19.0,
        41.0, 65.0, 4.0, 12.2,
        95.0, 77.0, 32.0, 48.0
    ];

    location = gl.getUniformLocation(program, 'arrayUniform');
    gl.uniform1fv(location, new Float32Array(uniformValue.slice(0, 5)));

    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[0]'), uniformValue[0]));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[1]'), uniformValue[1]));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[2]'), uniformValue[2]));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[3]'), uniformValue[3]));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[4]'), uniformValue[4]));

    location = gl.getUniformLocation(program, 'array2Uniform');
    gl.uniform2fv(location, new Float32Array(uniformValue.slice(0, 10)));

    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[0]'), new Float32Array([uniformValue[2 * 0], uniformValue[(2 * 0) + 1]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[1]'), new Float32Array([uniformValue[2 * 1], uniformValue[(2 * 1) + 1]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[2]'), new Float32Array([uniformValue[2 * 2], uniformValue[(2 * 2) + 1]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[3]'), new Float32Array([uniformValue[2 * 3], uniformValue[(2 * 3) + 1]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[4]'), new Float32Array([uniformValue[2 * 4], uniformValue[(2 * 4) + 1]])));

    location = gl.getUniformLocation(program, 'array3Uniform');
    gl.uniform3fv(location, new Float32Array(uniformValue.slice(0, 15)));

    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[0]'), new Float32Array([uniformValue[3 * 0], uniformValue[(3 * 0) + 1], uniformValue[(3 * 0) + 2]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[1]'), new Float32Array([uniformValue[3 * 1], uniformValue[(3 * 1) + 1], uniformValue[(3 * 1) + 2]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[2]'), new Float32Array([uniformValue[3 * 2], uniformValue[(3 * 2) + 1], uniformValue[(3 * 2) + 2]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[3]'), new Float32Array([uniformValue[3 * 3], uniformValue[(3 * 3) + 1], uniformValue[(3 * 3) + 2]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[4]'), new Float32Array([uniformValue[3 * 4], uniformValue[(3 * 4) + 1], uniformValue[(3 * 4) + 2]])));

    location = gl.getUniformLocation(program, 'array4Uniform');
    gl.uniform4fv(location, new Float32Array(uniformValue));

    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[0]'), new Float32Array([uniformValue[4 * 0], uniformValue[(4 * 0) + 1], uniformValue[(4 * 0) + 2], uniformValue[(4 * 0) + 3]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[1]'), new Float32Array([uniformValue[4 * 1], uniformValue[(4 * 1) + 1], uniformValue[(4 * 1) + 2], uniformValue[(4 * 1) + 3]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[2]'), new Float32Array([uniformValue[4 * 2], uniformValue[(4 * 2) + 1], uniformValue[(4 * 2) + 2], uniformValue[(4 * 2) + 3]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[3]'), new Float32Array([uniformValue[4 * 3], uniformValue[(4 * 3) + 1], uniformValue[(4 * 3) + 2], uniformValue[(4 * 3) + 3]])));
    this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[4]'), new Float32Array([uniformValue[4 * 4], uniformValue[(4 * 4) + 1], uniformValue[(4 * 4) + 2], uniformValue[(4 * 4) + 3]])));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 */
es3fShaderStateQueryTests.UniformValueMatrixCase = function(name, description) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
};

setParentClass(es3fShaderStateQueryTests.UniformValueMatrixCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.UniformValueMatrixCase.prototype.test = function() {
    var transpose = function(rows, cols, data) {
        var matrix = tcuMatrix.matrixFromDataArray(rows, cols, data);
        var result = [];
        for (var col = 0; col < cols; col++)
            result.push(matrix.getColumn(col));
        return new Float32Array([].concat.apply([], result));
    };

    var testVertSource =
        '#version 300 es\n' +
        'uniform highp mat2 mat2Uniform;' +
        'uniform highp mat3 mat3Uniform;' +
        'uniform highp mat4 mat4Uniform;' +
        'void main (void)\n' +
        '{\n' +
        ' gl_Position = vec4(mat2Uniform[0][0] + mat3Uniform[0][0] + mat4Uniform[0][0]);\n' +
        '}\n';
    var testFragSource =
        '#version 300 es\n' +
        'layout(location = 0) out mediump vec4 fragColor;' +
        'void main (void)\n' +
        '{\n' +
        ' fragColor = vec4(0.0);\n' +
        '}\n';

    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);

    gl.shaderSource(shaderVert, testVertSource);
    gl.shaderSource(shaderFrag, testFragSource);

    gl.compileShader(shaderVert);
    gl.compileShader(shaderFrag);

    var program = gl.createProgram();
    gl.attachShader(program, shaderVert);
    gl.attachShader(program, shaderFrag);
    gl.linkProgram(program);
    gl.useProgram(program);

    var location;

    var matrixValues = [
        -1.0, 0.1, 4.0, 800.0,
        13.0, 55.0, 12.0, 91.0,
        -55.1, 1.1, 98.0, 19.0,
        41.0, 65.0, 4.0, 12.0
    ];

    // the values of the matrix are returned in column major order but they can be given in either order

    location = gl.getUniformLocation(program, 'mat2Uniform');
    var m2 = new Float32Array(matrixValues.slice(0, 2 * 2));
    gl.uniformMatrix2fv(location, false, m2);
    this.check(glsStateQuery.verifyUniform(program, location, m2));
    gl.uniformMatrix2fv(location, true, m2);
    this.check(glsStateQuery.verifyUniform(program, location, transpose(2, 2, m2)));

    location = gl.getUniformLocation(program, 'mat3Uniform');
    var m3 = new Float32Array(matrixValues.slice(0, 3 * 3));
    gl.uniformMatrix3fv(location, false, m3);
    this.check(glsStateQuery.verifyUniform(program, location, m3));
    gl.uniformMatrix3fv(location, true, m3);
    this.check(glsStateQuery.verifyUniform(program, location, transpose(3, 3, m3)));

    location = gl.getUniformLocation(program, 'mat4Uniform');
    var m4 = new Float32Array(matrixValues.slice(0, 4 * 4));
    gl.uniformMatrix4fv(location, false, m4);
    this.check(glsStateQuery.verifyUniform(program, location, m4));
    gl.uniformMatrix4fv(location, true, m4);
    this.check(glsStateQuery.verifyUniform(program, location, transpose(4, 4, m4)));

    gl.useProgram(null);
    gl.deleteShader(shaderVert);
    gl.deleteShader(shaderFrag);
    gl.deleteProgram(program);
};

/**
 * @constructor
 * @extends {es3fApiCase.ApiCase}
 * @param {string} name
 * @param {string} description
 * @param {number} shaderType
 * @param {number} precisionType
 */
es3fShaderStateQueryTests.PrecisionFormatCase = function(name, description, shaderType, precisionType) {
    es3fApiCase.ApiCase.call(this, name, description, gl);
    this.m_shaderType = shaderType;
    this.m_precisionType = precisionType;
};

setParentClass(es3fShaderStateQueryTests.PrecisionFormatCase, es3fApiCase.ApiCase);

es3fShaderStateQueryTests.PrecisionFormatCase.prototype.test = function() {
    var requirements = {};
    requirements[gl.LOW_FLOAT] = [0, 0, 8];
    requirements[gl.MEDIUM_FLOAT] = [13, 13, 10];
    requirements[gl.HIGH_FLOAT] = [127, 127, 23];
    requirements[gl.LOW_INT] = [8, 7, 0];
    requirements[gl.MEDIUM_INT] = [15, 14, 0];
    requirements[gl.HIGH_INT] = [31, 30, 0];


    var expected = requirements[this.m_precisionType];
    var result = gl.getShaderPrecisionFormat(this.m_shaderType, this.m_precisionType);

    bufferedLogToConsole('Precision:' +
                ' range min = ' + result.rangeMin +
                ' range max = ' + result.rangeMax +
                ' precision = ' + result.precision);

    if (this.m_precisionType == gl.HIGH_FLOAT) {
        // highp float must be IEEE 754 single

        this.check(result.rangeMin == expected[0] ||
            result.rangeMax == expected[1] ||
            result.precision == expected[2],
                'Invalid precision format, expected:' +
                ' range min = ' + expected[0] +
                ' range max = ' + expected[1] +
                ' precision = ' + expected[2]);
    } else{
        this.check(result.rangeMin >= expected[0] ||
            result.rangeMax >= expected[1] ||
            result.precision >= expected[2],
                'Invalid precision format, expected:' +
                ' range min >= ' + expected[0] +
                ' range max >= ' + expected[1] +
                ' precision >= ' + expected[2]);
    }
};

/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderStateQueryTests.ShaderStateQueryTests = function() {
    tcuTestCase.DeqpTest.call(this, 'shader', 'Shader State Query tests');
};

es3fShaderStateQueryTests.ShaderStateQueryTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderStateQueryTests.ShaderStateQueryTests.prototype.constructor = es3fShaderStateQueryTests.ShaderStateQueryTests;

es3fShaderStateQueryTests.ShaderStateQueryTests.prototype.init = function() {
    // shader
    this.addChild(new es3fShaderStateQueryTests.ShaderTypeCase('shader_type', 'SHADER_TYPE'));
    this.addChild(new es3fShaderStateQueryTests.ShaderCompileStatusCase('shader_compile_status', 'COMPILE_STATUS'));
    this.addChild(new es3fShaderStateQueryTests.ShaderInfoLogCase('shader_info_log', 'INFO_LOG'));
    this.addChild(new es3fShaderStateQueryTests.ShaderSourceCase('shader_source', 'SHADER_SOURCE'));

    // shader and program
    this.addChild(new es3fShaderStateQueryTests.DeleteStatusCase('delete_status', 'DELETE_STATUS'));

    // // vertex-attrib
    this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribInitialCase('current_vertex_attrib_initial', 'CURRENT_VERTEX_ATTRIB'));
    this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribFloatCase('current_vertex_attrib_float', 'CURRENT_VERTEX_ATTRIB'));
    this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribIntCase('current_vertex_attrib_int', 'CURRENT_VERTEX_ATTRIB'));
    this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribUintCase('current_vertex_attrib_uint', 'CURRENT_VERTEX_ATTRIB'));

    // // program
    this.addChild(new es3fShaderStateQueryTests.ProgramInfoLogCase('program_info_log', 'INFO_LOG'));
    this.addChild(new es3fShaderStateQueryTests.ProgramValidateStatusCase('program_validate_status', 'VALIDATE_STATUS'));
    this.addChild(new es3fShaderStateQueryTests.ProgramAttachedShadersCase('program_attached_shaders', 'ATTACHED_SHADERS'));

    this.addChild(new es3fShaderStateQueryTests.ProgramActiveUniformNameCase('program_active_uniform_name', 'ACTIVE_UNIFORMS'));
    this.addChild(new es3fShaderStateQueryTests.ProgramUniformCase('program_active_uniform_types', 'UNIFORM_TYPE, UNIFORM_SIZE, and UNIFORM_IS_ROW_MAJOR'));
    this.addChild(new es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase ("program_active_uniform_blocks", "ACTIVE_UNIFORM_BLOCK_x"));

    // transform feedback
    this.addChild(new es3fShaderStateQueryTests.TransformFeedbackCase('transform_feedback', 'TRANSFORM_FEEDBACK_BUFFER_MODE, TRANSFORM_FEEDBACK_VARYINGS, TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH'));

    // attribute related
    this.addChild(new es3fShaderStateQueryTests.ActiveAttributesCase('active_attributes', 'ACTIVE_ATTRIBUTES and ACTIVE_ATTRIBUTE_MAX_LENGTH'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeSizeCase('vertex_attrib_size', 'VERTEX_ATTRIB_ARRAY_SIZE'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeTypeCase('vertex_attrib_type', 'VERTEX_ATTRIB_ARRAY_TYPE'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeStrideCase('vertex_attrib_stride', 'VERTEX_ATTRIB_ARRAY_STRIDE'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeNormalizedCase('vertex_attrib_normalized', 'VERTEX_ATTRIB_ARRAY_NORMALIZED'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeIntegerCase('vertex_attrib_integer', 'VERTEX_ATTRIB_ARRAY_INTEGER'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeEnabledCase('vertex_attrib_array_enabled', 'VERTEX_ATTRIB_ARRAY_ENABLED'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeDivisorCase('vertex_attrib_array_divisor', 'VERTEX_ATTRIB_ARRAY_DIVISOR'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeBufferBindingCase('vertex_attrib_array_buffer_binding', 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING'));
    this.addChild(new es3fShaderStateQueryTests.VertexAttributeOffsetCase('vertex_attrib_offset', 'VERTEX_ATTRIB_ARRAY_POINTER'));

    // uniform values
    this.addChild(new es3fShaderStateQueryTests.UniformValueFloatCase('uniform_value_float', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueIntCase('uniform_value_int', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueUintCase('uniform_value_uint', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueBooleanCase('uniform_value_boolean', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueSamplerCase('uniform_value_sampler', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueArrayCase('uniform_value_array', 'GetUniform*'));
    this.addChild(new es3fShaderStateQueryTests.UniformValueMatrixCase('uniform_value_matrix', 'GetUniform*'));

    // precision format query
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_lowp_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.LOW_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_mediump_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.MEDIUM_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_highp_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.HIGH_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_lowp_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.LOW_INT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_mediump_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.MEDIUM_INT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_highp_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.HIGH_INT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_lowp_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.LOW_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_mediump_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_highp_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.HIGH_FLOAT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_lowp_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.LOW_INT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_mediump_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.MEDIUM_INT));
    this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_highp_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.HIGH_INT));
};

/**
* Run test
* @param {WebGL2RenderingContext} context
*/
es3fShaderStateQueryTests.run = function(context) {
    gl = context;
    //Set up Test Root parameters
    var state = tcuTestCase.runner;
    state.setRoot(new es3fShaderStateQueryTests.ShaderStateQueryTests());

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

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

});