/*-------------------------------------------------------------------------
 * 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.es3fNegativeShaderApiTests');
goog.require('framework.common.tcuTestCase');
goog.require('framework.opengl.gluShaderProgram');
goog.require('functional.gles3.es3fApiCase');

goog.scope(function() {

    var es3fNegativeShaderApiTests = functional.gles3.es3fNegativeShaderApiTests;
    var es3fApiCase = functional.gles3.es3fApiCase;
    var tcuTestCase = framework.common.tcuTestCase;
    var gluShaderProgram = framework.opengl.gluShaderProgram;

    /**
    * @type {string}
    * @const
    */
    var vertexShaderSource = '#version 300 es\n' +
    'void main (void)\n' +
    '{\n' +
    ' gl_Position = vec4(0.0);\n' +
    '}\n';

    /**
    * @type {string}
    * @const
    */
    var fragmentShaderSource = '#version 300 es\n' +
    'layout(location = 0) out mediump vec4 fragColor;\n' +
    'void main (void)\n' +
    '{\n' +
    ' fragColor = vec4(0.0);\n' +
    '}\n';

    /**
    * @type {string}
    * @const
    */
    var uniformTestVertSource = '#version 300 es\n' +
    'uniform mediump vec4 vec4_v;\n' +
    'uniform mediump mat4 mat4_v;\n' +
    'void main (void)\n' +
    '{\n' +
    ' gl_Position = mat4_v * vec4_v;\n' +
    '}\n';

    /**
    * @type {string}
    * @const
    */
    var uniformTestFragSource = '#version 300 es\n' +
    'uniform mediump ivec4 ivec4_f;\n' +
    'uniform mediump uvec4 uvec4_f;\n' +
    'uniform sampler2D sampler_f;\n' +
    'layout(location = 0) out mediump vec4 fragColor;\n' +
    'void main (void)\n' +
    '{\n' +
    ' fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n' +
    ' fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n' +
    '}\n';

    /**
    * @type {string}
    * @const
    */
    var uniformBlockVertSource = '#version 300 es\n' +
    'layout(std140) uniform Block { lowp float var; };\n' +
    'void main (void)\n' +
    '{\n' +
    ' gl_Position = vec4(var);\n' +
    '}\n';

    /**
    * @param {WebGL2RenderingContext} gl
    */
    es3fNegativeShaderApiTests.init = function(gl) {
        var testGroup = tcuTestCase.runner.testCases;

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'create_shader', 'Invalid gl.createShader() usage', gl,
            function() {
                bufferedLogToConsole('INVALID_ENUM is generated if shaderType is not an accepted value.');
                gl.createShader(-1);
                this.expectError(gl.INVALID_ENUM);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('attach_shader', 'Invalid gl.attachShader() usage', gl,
            function() {
                /** @type {WebGLShader} */ var shader1 = gl.createShader(gl.VERTEX_SHADER);
                /** @type {WebGLShader} */ var shader2 = gl.createShader(gl.VERTEX_SHADER);
                /** @type {WebGLProgram} */ var program = gl.createProgram();

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if shader is already attached to program.');
                gl.attachShader(program, shader1);
                    this.expectError(gl.NO_ERROR);
                gl.attachShader(program, shader1);
                    this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a shader of the same type as shader is already attached to program.');
                gl.attachShader(program, shader2);
                    this.expectError(gl.INVALID_OPERATION);

                gl.deleteProgram(program);
                gl.deleteShader(shader1);
                gl.deleteShader(shader2);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('detach_shader', 'Invalid gl.detachShader() usage', gl,
            function() {
                /** @type {WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
                /** @type {WebGLProgram} */ var program = gl.createProgram();

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if shader is not attached to program.');
                gl.detachShader(program, shader);
                this.expectError(gl.INVALID_OPERATION);

                gl.deleteProgram(program);
                gl.deleteShader(shader);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('link_program', 'Invalid gl.linkProgram() usage', gl,
            function() {

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if program is the currently active program object and transform feedback mode is active.');

                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {WebGLTransformFeedback} */ var tfID;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                tfID = gl.createTransformFeedback();
                buf = gl.createBuffer();

                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                gl.beginTransformFeedback(gl.TRIANGLES);

                this.expectError(gl.NO_ERROR);

                gl.linkProgram(program.getProgram());
                this.expectError(gl.INVALID_OPERATION);

                gl.endTransformFeedback();
                gl.deleteTransformFeedback(tfID);
                gl.deleteBuffer(buf);
                this.expectError(gl.NO_ERROR);

            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('use_program', 'Invalid gl.useProgram() usage', gl,
            function() {

                /** @type {WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if transform feedback mode is active and not paused.');
                /** @type {gluShaderProgram.ShaderProgram} */ var program1 = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {gluShaderProgram.ShaderProgram} */ var program2 = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {WebGLTransformFeedback} */ var tfID;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                tfID = gl.createTransformFeedback();
                buf = gl.createBuffer();

                gl.useProgram(program1.getProgram());
                gl.transformFeedbackVaryings(program1.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program1.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.NO_ERROR);

                gl.useProgram(program2.getProgram());
                this.expectError(gl.INVALID_OPERATION);

                gl.pauseTransformFeedback();
                gl.useProgram(program2.getProgram());
                this.expectError(gl.NO_ERROR);

                gl.endTransformFeedback();
                gl.deleteTransformFeedback(tfID);
                gl.deleteBuffer(buf);
                this.expectError(gl.NO_ERROR);

                gl.useProgram(null);
                gl.deleteShader(shader);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('bind_sampler', 'Invalid gl.bindSampler() usage', gl,
            function() {
                /** @type {number} */ var maxTexImageUnits;
                /** @type {WebGLSampler} */ var sampler;
                /** @type {WebGLSampler} */ var buf;
                maxTexImageUnits = /** @type {number} */ (gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS));
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_VALUE is generated if unit is greater than or equal to the value of gl.MAX_COMBIED_TEXTURE_IMAGE_UNITS.');
                gl.bindSampler(maxTexImageUnits, sampler);
                this.expectError(gl.INVALID_VALUE);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if sampler has been deleted by a call to glDeleteSamplers.');
                gl.deleteSampler(sampler);
                gl.bindSampler(1, sampler);
                this.expectError(gl.INVALID_OPERATION);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_sampler_parameteriv', 'Invalid gl.getSamplerParameter() usage', gl,
            function() {
                /** @type {number} */ var params;
                /** @type {WebGLSampler} */ var sampler;
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted value.');
                params = /** @type {number} */ (gl.getSamplerParameter(sampler, -1));
                this.expectError(gl.INVALID_ENUM);

                gl.deleteSampler(sampler);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_sampler_parameterfv', 'Invalid gl.getSamplerParameter() usage', gl,
            function() {
                /** @type {number} */ var params;
                /** @type {WebGLSampler} */ var sampler;
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted value.');
                params = /** @type {number} */ (gl.getSamplerParameter(sampler, -1));
                this.expectError(gl.INVALID_ENUM);

                gl.deleteSampler(sampler);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('sampler_parameteri', 'Invalid gl.samplerParameteri() usage', gl,
            function() {
                /** @type {WebGLSampler} */ var sampler;
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.');
                gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, -1);
                this.expectError(gl.INVALID_ENUM);

                gl.deleteSampler(sampler);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'sampler_parameteriv', 'Invalid gl.samplerParameteri() usage', gl,
            function() {
                /** @type {number} */ var params;
                /** @type {WebGLSampler} */ var sampler;
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.');
                params = -1;
                gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, params);
                this.expectError(gl.INVALID_ENUM);

                gl.deleteSampler(sampler);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'sampler_parameterf', 'Invalid glSamplerParameterf() usage', gl,
            function() {
                /** @type {WebGLSampler} */ var sampler;
                sampler = gl.createSampler();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.');
                gl.samplerParameterf(sampler, gl.TEXTURE_WRAP_S, -1.0);
                this.expectError(gl.INVALID_ENUM);

                gl.deleteSampler(sampler);
            }
        ));

        // Shader data commands

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'get_attrib_location', 'Invalid gl.getAttribLocation() usage', gl,
            function() {
                /** @type {WebGLProgram} */ var programEmpty = gl.createProgram();
                /** @type {WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if program has not been successfully linked.');
                gl.bindAttribLocation(programEmpty, 0, 'test');
                gl.getAttribLocation(programEmpty, 'test');
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
                gl.deleteShader(shader);
                gl.deleteProgram(programEmpty);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'get_uniform_location', 'Invalid gl.getUniformLocation() usage', gl,
            function() {
                /** @type {WebGLProgram} */ var programEmpty = gl.createProgram();

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if program has not been successfully linked.');
                gl.getUniformLocation(programEmpty, 'test');
                this.expectError(gl.INVALID_OPERATION);
                gl.deleteProgram(programEmpty);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback(
            'bind_attrib_location', 'Invalid gl.bindAttribLocation() usage', gl,
            function() {
                /** @type {WebGLProgram} */ var program = gl.createProgram();
                var maxIndex = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));

                bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater than or equal to gl.MAX_VERTEX_ATTRIBS.');
                gl.bindAttribLocation(program, maxIndex, 'test');
                this.expectError(gl.INVALID_VALUE);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if name starts with the reserved prefix \'gl.\'.');
                gl.bindAttribLocation(program, maxIndex-1, 'gl_test');
                this.expectError(gl.INVALID_OPERATION);

                gl.deleteProgram(program);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniform_block_binding', 'Invalid gl.uniformBlockBinding() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());

                /** @type {number} */ var maxUniformBufferBindings;
                /** @type {number} */ var numActiveUniforms = -1;
                /** @type {number} */ var numActiveBlocks = -1;
                maxUniformBufferBindings = /** @type {number} */ (gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS));
                numActiveUniforms = /** @type {number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORMS));
                numActiveBlocks = /** @type {number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORM_BLOCKS));
                bufferedLogToConsole('// gl.MAX_UNIFORM_BUFFER_BINDINGS = ' + maxUniformBufferBindings);
                bufferedLogToConsole('// gl.ACTIVE_UNIFORMS = ' + numActiveUniforms);
                bufferedLogToConsole('// gl.ACTIVE_UNIFORM_BLOCKS = ' + numActiveBlocks);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program.');
                gl.uniformBlockBinding(program.getProgram(), -1, 0);
                this.expectError(gl.INVALID_VALUE);
                gl.uniformBlockBinding(program.getProgram(), 5, 0);
                this.expectError(gl.INVALID_VALUE);

                bufferedLogToConsole('gl.INVALID_VALUE is generated if uniformBlockBinding is greater than or equal to the value of gl.MAX_UNIFORM_BUFFER_BINDINGS.');
                gl.uniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0);
                this.expectError(gl.INVALID_VALUE);

                bufferedLogToConsole('An exception is thrown if program is null.');
                this.expectThrowNoError(function() {
                    gl.uniformBlockBinding(null, 0, 0);
                });
            }
        ));

        // glUniform*f

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformf_incompatible_type', 'Invalid glUniform{1234}f() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null) {
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);
                }

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1f(vec4_v, 0.0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2f(vec4_v, 0.0, 0.0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3f(vec4_v, 0.0, 0.0, 0.0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4f(vec4_v, 0.0, 0.0, 0.0, 0.0);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}f is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.');
                gl.useProgram(program.getProgram());
                gl.uniform4f(ivec4_f, 0.0, 0.0, 0.0, 0.0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4f(uvec4_f, 0.0, 0.0, 0.0, 0.0);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.');
                gl.useProgram(program.getProgram());
                gl.uniform1f(sampler_f, 0.0);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformfv_incompatible_type', 'Invalid glUniform{1234}fv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Float32Array} */ var data = new Float32Array(4);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1fv(vec4_v, new Float32Array(1));
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2fv(vec4_v, new Float32Array(2));
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3fv(vec4_v, new Float32Array(3));
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4fv(vec4_v, new Float32Array(4));
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}fv is used to load a uniform variable of type /** @type {number} */ var , ivec2, ivec3, ivec4, unsigned /** @type {number} */ var , uvec2, uvec3, uvec4.');
                gl.useProgram(program.getProgram());
                gl.uniform4fv(ivec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4fv(uvec4_f, data);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.');
                gl.useProgram(program.getProgram());
                gl.uniform1fv(sampler_f, new Float32Array(1));
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformfv_invalid_count', 'Invalid glUniform{1234}fv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Float32Array} */ var data = new Float32Array(12);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.');
                gl.useProgram(program.getProgram());
                gl.uniform1fv(vec4_v, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2fv(vec4_v, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3fv(vec4_v, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4fv(vec4_v, data);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformi_incompatible_type', 'Invalid glUniform{1234}i() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1i(ivec4_f, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2i(ivec4_f, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3i(ivec4_f, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4i(ivec4_f, 0, 0, 0, 0);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type unsigned /** @type {number} */ var , uvec2, uvec3, uvec4, or an array of these.');
                gl.useProgram(program.getProgram());
                gl.uniform1i(uvec4_f, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2i(uvec4_f, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3i(uvec4_f, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4i(uvec4_f, 0, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type /** @type {number} */ var , vec2, vec3, or vec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1i(vec4_v, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2i(vec4_v, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3i(vec4_v, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4i(vec4_v, 0, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformiv_incompatible_type', 'Invalid glUniform{1234}iv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Int32Array} */ var data1 = new Int32Array(1);
                /** @type {Int32Array} */ var data2 = new Int32Array(2);
                /** @type {Int32Array} */ var data3 = new Int32Array(3);
                /** @type {Int32Array} */ var data4 = new Int32Array(4);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1iv(ivec4_f, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2iv(ivec4_f, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3iv(ivec4_f, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4iv(ivec4_f, data4);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type /** @type {number} */ var , vec2, vec3, or vec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1iv(vec4_v, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2iv(vec4_v, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3iv(vec4_v, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4iv(vec4_v, data4);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type unsigned /** @type {number} */ var , uvec2, uvec3 or uvec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1iv(uvec4_f, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2iv(uvec4_f, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3iv(uvec4_f, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4iv(uvec4_f, data4);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformiv_invalid_count', 'Invalid glUniform{1234}iv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                this.expectError(gl.NO_ERROR);

                if (ivec4_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Int32Array} */ var data = new Int32Array(12);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.');
                gl.useProgram(program.getProgram());
                gl.uniform1iv(ivec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2iv(ivec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3iv(ivec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4iv(ivec4_f, data);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformui_incompatible_type', 'Invalid glUniform{1234}ui() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1ui(uvec4_f, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2ui(uvec4_f, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3ui(uvec4_f, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4ui(uvec4_f, 0, 0, 0, 0);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type /** @type {number} */ var , ivec2, ivec3, ivec4, or an array of these.');
                gl.useProgram(program.getProgram());
                gl.uniform1ui(ivec4_f, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2ui(ivec4_f, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3ui(ivec4_f, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4ui(ivec4_f, 0, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type /** @type {number} */ var , vec2, vec3, or vec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1ui(vec4_v, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2ui(vec4_v, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3ui(vec4_v, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4ui(vec4_v, 0, 0, 0, 0);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.');
                gl.useProgram(program.getProgram());
                gl.uniform1ui(sampler_f, 0);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformuiv_incompatible_type', 'Invalid glUniform{1234}uiv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var vec4_v = gl.getUniformLocation(program.getProgram(), 'vec4_v'); // vec4
                /** @type {WebGLUniformLocation} */ var ivec4_f = gl.getUniformLocation(program.getProgram(), 'ivec4_f'); // ivec4
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (vec4_v == null || ivec4_f == null || uvec4_f == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Uint32Array} */ var data1 = new Uint32Array(1);
                /** @type {Uint32Array} */ var data2 = new Uint32Array(2);
                /** @type {Uint32Array} */ var data3 = new Uint32Array(3);
                /** @type {Uint32Array} */ var data4 = new Uint32Array(4);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniform1uiv(uvec4_f, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2uiv(uvec4_f, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3uiv(uvec4_f, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4uiv(uvec4_f, data4);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type /** @type {number} */ var , vec2, vec3, or vec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1uiv(vec4_v, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2uiv(vec4_v, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3uiv(vec4_v, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4uiv(vec4_v, data4);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type /** @type {number} */ var , ivec2, ivec3 or ivec4.');
                gl.useProgram(program.getProgram());
                gl.uniform1uiv(ivec4_f, data1);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2uiv(ivec4_f, data2);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3uiv(ivec4_f, data3);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4uiv(ivec4_f, data4);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.');
                gl.useProgram(program.getProgram());
                gl.uniform1uiv(sampler_f, data1);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniformuiv_invalid_count', 'Invalid glUniform{1234}uiv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var uvec4_f = gl.getUniformLocation(program.getProgram(), 'uvec4_f'); // uvec4
                this.expectError(gl.NO_ERROR);

                if (uvec4_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Uint32Array} */ var data = new Uint32Array(12);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.');
                gl.useProgram(program.getProgram());
                gl.uniform1uiv(uvec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform2uiv(uvec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform3uiv(uvec4_f, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniform4uiv(uvec4_f, data);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniform_matrixfv_incompatible_type', 'Invalid glUniformMatrix{234}fv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var mat4_v = gl.getUniformLocation(program.getProgram(), 'mat4_v'); // mat4
                /** @type {WebGLUniformLocation} */ var sampler_f = gl.getUniformLocation(program.getProgram(), 'sampler_f'); // sampler2D
                this.expectError(gl.NO_ERROR);

                if (mat4_v == null || sampler_f == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Float32Array} */ var data4 = new Float32Array(4);
                /** @type {Float32Array} */ var data9 = new Float32Array(9);
                /** @type {Float32Array} */ var data16 = new Float32Array(16);
                /** @type {Float32Array} */ var data6 = new Float32Array(6);
                /** @type {Float32Array} */ var data8 = new Float32Array(8);
                /** @type {Float32Array} */ var data12 = new Float32Array(12);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.');
                gl.useProgram(program.getProgram());
                gl.uniformMatrix2fv(mat4_v, false, data4);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3fv(mat4_v, false, data9);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4fv(mat4_v, false, data16);
                this.expectError(gl.NO_ERROR);

                gl.uniformMatrix2x3fv(mat4_v, false, data6);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x2fv(mat4_v, false, data6);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix2x4fv(mat4_v, false, data8);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x2fv(mat4_v, false, data8);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x4fv(mat4_v, false, data12);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x3fv(mat4_v, false, data12);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.');
                gl.useProgram(program.getProgram());
                gl.uniformMatrix2fv(sampler_f, false, data4);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3fv(sampler_f, false, data9);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4fv(sampler_f, false, data16);
                this.expectError(gl.INVALID_OPERATION);

                gl.uniformMatrix2x3fv(sampler_f, false, data6);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x2fv(sampler_f, false, data6);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix2x4fv(sampler_f, false, data8);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x2fv(sampler_f, false, data8);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x4fv(sampler_f, false, data12);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x3fv(sampler_f, false, data12);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('uniform_matrixfv_invalid_count', 'Invalid glUniformMatrix{234}fv() usage', gl,
            function() {
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));

                gl.useProgram(program.getProgram());
                /** @type {WebGLUniformLocation} */ var mat4_v = gl.getUniformLocation(program.getProgram(), 'mat4_v'); // mat4
                this.expectError(gl.NO_ERROR);

                if (mat4_v == null)
                    assertMsgOptions(false, 'Failed to retrieve uniform location', false, true);

                /** @type {Float32Array} */ var data = new Float32Array(144);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.');
                gl.useProgram(program.getProgram());
                gl.uniformMatrix2fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);

                gl.uniformMatrix2x3fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x2fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix2x4fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x2fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix3x4fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);
                gl.uniformMatrix4x3fv(mat4_v, false, data);
                this.expectError(gl.INVALID_OPERATION);

                gl.useProgram(null);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('bind_transform_feedback', 'Invalid gl.bindTransformFeedback() usage', gl,
            function() {
                /** @type {Array<WebGLTransformFeedback>} */ var tfID = [];
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                buf = gl.createBuffer();
                tfID[0] = gl.createTransformFeedback();
                tfID[1] = gl.createTransformFeedback();

                bufferedLogToConsole('gl.INVALID_ENUM is generated if target is not gl.TRANSFORM_FEEDBACK.');
                gl.bindTransformFeedback(-1, tfID[0]);
                this.expectError(gl.INVALID_ENUM);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the transform feedback operation is active on the currently bound transform feedback object, and is not paused.');
                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID[0]);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.NO_ERROR);

                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID[1]);
                this.expectError(gl.INVALID_OPERATION);

                gl.endTransformFeedback();
                this.expectError(gl.NO_ERROR);

                gl.useProgram(null);
                gl.deleteBuffer(buf);
                gl.deleteTransformFeedback(tfID[0]);
                gl.deleteTransformFeedback(tfID[1]);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('begin_transform_feedback', 'Invalid gl.beginTransformFeedback() usage', gl,
            function() {
                /** @type {Array<WebGLTransformFeedback>} */ var tfID = [];
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                buf = gl.createBuffer();
                tfID[0] = gl.createTransformFeedback();
                tfID[1] = gl.createTransformFeedback();

                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID[0]);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_ENUM is generated if primitiveMode is not one of gl.POINTS, gl.LINES, or gl.TRIANGLES.');
                gl.beginTransformFeedback(-1);
                this.expectError(gl.INVALID_ENUM);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if transform feedback is already active.');
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.NO_ERROR);
                gl.beginTransformFeedback(gl.POINTS);
                this.expectError(gl.INVALID_OPERATION);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if any binding point used in transform feedback mode does not have a buffer object bound.');
                /** @type{WebGLBuffer} */ var dummyBuf = gl.createBuffer()
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, dummyBuf);
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.INVALID_OPERATION);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if no binding points would be used because no program object is active.');
                gl.useProgram(null);
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.INVALID_OPERATION);
                gl.useProgram(program.getProgram());

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if no binding points would be used because the active program object has specified no varying variables to record.');
                gl.transformFeedbackVaryings(program.getProgram(), [], gl.INTERLEAVED_ATTRIBS);
                gl.beginTransformFeedback(gl.TRIANGLES);
                this.expectError(gl.INVALID_OPERATION);

                gl.endTransformFeedback();
                gl.deleteBuffer(buf);
                gl.deleteBuffer(dummyBuf);
                gl.deleteTransformFeedback(tfID[0]);
                gl.deleteTransformFeedback(tfID[1]);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('pause_transform_feedback', 'Invalid gl.pauseTransformFeedback() usage', gl,
            function() {
                /** @type {Array<WebGLTransformFeedback>} */ var tfID = [];
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                buf = gl.createBuffer();
                tfID[0] = gl.createTransformFeedback();
                tfID[1] = gl.createTransformFeedback();

                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID[0]);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is paused.');
                gl.pauseTransformFeedback();
                this.expectError(gl.INVALID_OPERATION);
                gl.beginTransformFeedback(gl.TRIANGLES);
                gl.pauseTransformFeedback();
                this.expectError(gl.NO_ERROR);
                gl.pauseTransformFeedback();
                this.expectError(gl.INVALID_OPERATION);

                gl.endTransformFeedback();
                gl.deleteBuffer(buf);
                gl.deleteTransformFeedback(tfID[0]);
                gl.deleteTransformFeedback(tfID[1]);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('resume_transform_feedback', 'Invalid gl.resumeTransformFeedback() usage', gl,
            function() {
                /** @type {Array<WebGLTransformFeedback>} */ var tfID = [];
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                buf = gl.createBuffer();
                tfID[0] = gl.createTransformFeedback();
                tfID[1] = gl.createTransformFeedback();

                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID[0]);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is not paused.');
                gl.resumeTransformFeedback();
                this.expectError(gl.INVALID_OPERATION);
                gl.beginTransformFeedback(gl.TRIANGLES);
                gl.resumeTransformFeedback();
                this.expectError(gl.INVALID_OPERATION);
                gl.pauseTransformFeedback();
                gl.resumeTransformFeedback();
                this.expectError(gl.NO_ERROR);

                gl.endTransformFeedback();
                gl.deleteBuffer(buf);
                gl.deleteTransformFeedback(tfID[0]);
                gl.deleteTransformFeedback(tfID[1]);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('end_transform_feedback', 'Invalid gl.endTransformFeedback() usage', gl,
            function() {
                /** @type {WebGLTransformFeedback} */ var tfID;
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {WebGLBuffer} */ var buf;
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];

                buf = gl.createBuffer();
                tfID = gl.createTransformFeedback();

                gl.useProgram(program.getProgram());
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                gl.linkProgram(program.getProgram());
                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID);
                gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buf);
                gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 32, gl.DYNAMIC_DRAW);
                gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('gl.INVALID_OPERATION is generated if transform feedback is not active.');
                gl.endTransformFeedback();
                this.expectError(gl.INVALID_OPERATION);
                gl.beginTransformFeedback(gl.TRIANGLES);
                gl.endTransformFeedback();
                this.expectError(gl.NO_ERROR);

                gl.deleteBuffer(buf);
                gl.deleteTransformFeedback(tfID);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_transform_feedback_varying', 'Invalid glGetTransformFeedbackVarying() usage', gl,
            function() {
                /** @type {WebGLTransformFeedback} */ var tfID;
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {gluShaderProgram.ShaderProgram} */ var programInvalid = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, ''));
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];
                /** @type {number} */ var maxTransformFeedbackVaryings = 0;

                /** @type {number} */ var length;
                /** @type {number} */ var size;
                /** @type {number} */ var type;
                /** @type {WebGLActiveInfo} */ var name;

                tfID = gl.createTransformFeedback();

                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.INTERLEAVED_ATTRIBS);
                this.expectError(gl.NO_ERROR);
                gl.linkProgram(program.getProgram());
                this.expectError(gl.NO_ERROR);

                gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tfID);
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('An exception is thrown if program is null.');
                this.expectThrowNoError(function() {
                    gl.getTransformFeedbackVarying(null, 0);
                });

                bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater or equal to the value of gl.TRANSFORM_FEEDBACK_VARYINGS.');
                maxTransformFeedbackVaryings = /** @type {number} */ (gl.getProgramParameter(program.getProgram(), gl.TRANSFORM_FEEDBACK_VARYINGS));
                name = gl.getTransformFeedbackVarying(program.getProgram(), maxTransformFeedbackVaryings);
                this.expectError(gl.INVALID_VALUE);

                bufferedLogToConsole('gl.INVALID_OPERATION or gl.INVALID_VALUE is generated program has not been linked.');
                name = gl.getTransformFeedbackVarying(programInvalid.getProgram(), 0);
                this.expectError([gl.INVALID_OPERATION, gl.INVALID_VALUE]);

                gl.deleteTransformFeedback(tfID);
                this.expectError(gl.NO_ERROR);
            }
        ));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('transform_feedback_varyings', 'Invalid gl.transformFeedbackVaryings() usage', gl,
            function() {
                /** @type {WebGLTransformFeedback} */ var tfID;
                /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
                /** @type {Array<string>} */ var tfVarying = ['gl_Position'];
                /** @type {number} */ var maxTransformFeedbackSeparateAttribs = 0;

                tfID = gl.createTransformFeedback();
                this.expectError(gl.NO_ERROR);

                bufferedLogToConsole('An exception is thrown if program is null.');
                this.expectThrowNoError(function() {
                    gl.transformFeedbackVaryings(null, tfVarying, gl.INTERLEAVED_ATTRIBS);
                });

                bufferedLogToConsole('gl.INVALID_VALUE is generated if bufferMode is gl.SEPARATE_ATTRIBS and count is greater than gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.');
                maxTransformFeedbackSeparateAttribs = /** @type {number} */ (gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS));
                for (var count = 0; count < maxTransformFeedbackSeparateAttribs; ++count) {
                    tfVarying = tfVarying.concat(['gl_Position']);
                }
                gl.transformFeedbackVaryings(program.getProgram(), tfVarying, gl.SEPARATE_ATTRIBS);
                this.expectError(gl.INVALID_VALUE);

                gl.deleteTransformFeedback(tfID);
                this.expectError(gl.NO_ERROR);
            }
        ));
    };

    /**
     * Run test
     * @param {WebGL2RenderingContext} gl
     */
     es3fNegativeShaderApiTests.run = function(gl) {
        //Set up Test Root parameters
        var testName = 'negative_shader_api';
        var testDescription = 'Negative Shader Api Tests';
        var state = tcuTestCase.runner;

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

        //Set up name and description of this test series.
        setCurrentTestName(testName);
        description(testDescription);
        try {
            es3fNegativeShaderApiTests.init(gl);
            tcuTestCase.runner.runCallback(tcuTestCase.runTestCases);
        } catch (err) {
            bufferedLogToConsole(err);
            tcuTestCase.runner.terminate();
        }
    };
});