/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 Module
 * -------------------------------------------------
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Negative GL State API tests.
 *//*--------------------------------------------------------------------*/
'use strict';
goog.provide('functional.gles3.es3fNegativeStateApiTests');

goog.require('framework.common.tcuTestCase');
goog.require('functional.gles3.es3fApiCase');
goog.require('framework.opengl.gluShaderProgram');

goog.scope(function() {

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

    /**
    * @type {string}
    * @const
    */
    var uniformTestVertSource = '#version 300 es\n' +
    'uniform mediump vec4 vUnif_vec4;\n' +
    'in mediump vec4 attr;\n' +
    'layout(std140) uniform Block { mediump vec4 blockVar; };\n' +
    'void main (void)\n' +
    '{\n' +
    ' gl_Position = vUnif_vec4 + blockVar + attr;\n' +
    '}\n';

    /**
    * @type {string}
    * @const
    */
    var uniformTestFragSource = '#version 300 es\n' +
    'uniform mediump ivec4 fUnif_ivec4;\n' +
    'uniform mediump uvec4 fUnif_uvec4;\n' +
    'layout(location = 0) out mediump vec4 fragColor;\n' +
    'void main (void)\n' +
    '{\n' +
    ' fragColor = vec4(vec4(fUnif_ivec4) + vec4(fUnif_uvec4));\n' +
    '}\n';

    /**
    * @param {WebGL2RenderingContext} gl
    */
    es3fNegativeStateApiTests.init = function(gl) {

        var testGroup = tcuTestCase.runner.testCases;

        // Enabling & disabling states

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('enable', 'Invalid gl.enable() usage', gl, function() {
            bufferedLogToConsole('gl.INVALID_ENUM is generated if cap is not one of the allowed values.');
            gl.enable(-1);
            this.expectError(gl.INVALID_ENUM);

        }));
        testGroup.addChild(new es3fApiCase.ApiCaseCallback('disable', 'Invalid gl.disable() usage', gl, function() {
            bufferedLogToConsole('gl.INVALID_ENUM is generated if cap is not one of the allowed values.');
            gl.disable(-1);
            this.expectError(gl.INVALID_ENUM);

        }));

        // Simple state queries

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_parameter', 'Invalid gl.getParameter() usage', gl, function() {
            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not one of the allowed values.');
            /** @type{boolean} */ var params = false;
            //glGetBooleanv(-1, params);
            params = /** @type{boolean} */ (gl.getParameter(-1));
            this.expectError(gl.INVALID_ENUM);

        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_indexed_parameter', 'Invalid gl.getIndexedParameter() usage', gl, function() {
            /** @type{number} */ var data = -1;
            /** @type{number} */ var maxUniformBufferBindings;

            bufferedLogToConsole('gl.INVALID_ENUM is generated if name is not an accepted value.');
            data = /** @type{number} */ (gl.getIndexedParameter(-1, 0));
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.');
            maxUniformBufferBindings = /** @type{number} */ (gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS));
            this.expectError(gl.NO_ERROR);
            data = /** @type{number} */ (gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, maxUniformBufferBindings));
            this.expectError(gl.INVALID_VALUE);

        }));

        // Enumerated state queries: Shaders

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

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

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_shader_parameter', 'Invalid gl.getShaderParameter() usage', gl, function() {
            /** @type{WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
            /** @type{WebGLProgram} */ var program = gl.createProgram();
            /** @type{number} */ var param = -1;

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

            bufferedLogToConsole('An exception is thrown if shader is null.');
            this.expectThrowNoError(function() {
                gl.getShaderParameter(null, gl.SHADER_TYPE);
            });

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

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

            bufferedLogToConsole('An exception is thrown if shader is null.');
            this.expectThrowNoError(function() {
                gl.getShaderInfoLog(null);
            });

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_shader_precision_format', 'Invalid gl.getShaderPrecisionFormat() usage', gl, function() {
            /** @type{WebGLShaderPrecisionFormat } */ var precision;

            bufferedLogToConsole('gl.INVALID_ENUM is generated if shaderType or precisionType is not an accepted value.');
            precision = gl.getShaderPrecisionFormat (-1, gl.MEDIUM_FLOAT);
            this.expectError(gl.INVALID_ENUM);
            precision = gl.getShaderPrecisionFormat (gl.VERTEX_SHADER, -1);
            this.expectError(gl.INVALID_ENUM);
            precision = gl.getShaderPrecisionFormat (-1, -1);
            this.expectError(gl.INVALID_ENUM);

        }));

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

            bufferedLogToConsole('An exception is thrown if shader is null.');
            this.expectThrowNoError(function() {
                gl.getShaderSource(null);
            });

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

        // Enumerated state queries: Programs

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

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

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

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

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

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

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

        // Enumerated state queries: Shader variables

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_tex_parameter', 'Invalid gl.getTexParameter() usage', gl, function() {
            /** @type{WebGLTexture} */ var texture = gl.createTexture();
            gl.bindTexture(gl.TEXTURE_2D, texture);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target or pname is not an accepted value.');
            gl.getTexParameter (-1, gl.TEXTURE_MAG_FILTER);
            this.expectError(gl.INVALID_ENUM);
            gl.getTexParameter (gl.TEXTURE_2D, -1);
            this.expectError(gl.INVALID_ENUM);
            gl.getTexParameter (-1, -1);
            this.expectError(gl.INVALID_ENUM);

            gl.deleteTexture(texture);

        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_uniform', 'Invalid gl.getUniform() usage', gl, function() {
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            gl.useProgram(program.getProgram());

            /** @type{WebGLUniformLocation} */ var unif = gl.getUniformLocation(program.getProgram(), 'vUnif_vec4'); // vec4
            assertMsgOptions(unif != null, 'Failed to retrieve uniform location', false, true);

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

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

            bufferedLogToConsole('gl.INVALID_OPERATION is generated if program has not been successfully linked.');
            params = gl.getUniform (programEmpty, unif);
            this.expectError(gl.INVALID_OPERATION);

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

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_active_uniform', 'Invalid gl.getActiveUniform() usage', gl, function() {
            /** @type{WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            /** @type{number} */ var numActiveUniforms = -1;

            numActiveUniforms = /** @type{number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORMS));
            bufferedLogToConsole('// gl.ACTIVE_UNIFORMS = ' + numActiveUniforms + ' (expected 4).');

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

            bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater than or equal to the number of active uniform variables in program.');
            gl.useProgram(program.getProgram());
            gl.getActiveUniform(program.getProgram(), numActiveUniforms);
            this.expectError(gl.INVALID_VALUE);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_active_uniforms', 'Invalid gl.getActiveUniforms() usage', gl, function() {
            /** @type{WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            /** @type{Array<number>} */ var dummyUniformIndex = [1];
            /** @type{Array<number>} */ var dummyParamDst;
            /** @type{number} */ var numActiveUniforms = -1;

            gl.useProgram(program.getProgram());

            numActiveUniforms = /** @type{number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORMS));
            bufferedLogToConsole('// gl.ACTIVE_UNIFORMS = ' + numActiveUniforms + ' (expected 4).');

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

            bufferedLogToConsole('gl.INVALID_VALUE is generated if any value in uniformIndices is greater than or equal to the value of gl.ACTIVE_UNIFORMS for program.');
            /** @type{Array<number>} */ var invalidUniformIndices;
            /** @type{Array<number>} */ var dummyParamsDst;
            for (var excess = 0; excess <= 2; excess++) {
                invalidUniformIndices = [1, numActiveUniforms - 1 + excess, 1];
                dummyParamsDst = gl.getActiveUniforms(program.getProgram(), invalidUniformIndices, gl.UNIFORM_TYPE);
                this.expectError(excess == 0 ? gl.NO_ERROR : gl.INVALID_VALUE);
            }

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted token.');
            dummyParamDst = gl.getActiveUniforms(program.getProgram(), dummyUniformIndex, -1);
            this.expectError(gl.INVALID_ENUM);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_active_uniform_block_parameter', 'Invalid gl.getActiveUniformBlockParameter() usage', gl, function() {
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            /** @type{*} */ var params;
            /** @type{number} */ var numActiveBlocks = -1;

            numActiveBlocks = /** @type{number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORM_BLOCKS));
            bufferedLogToConsole('// gl.ACTIVE_UNIFORM_BLOCKS = ' + numActiveBlocks + ' (expected 1).');
            this.expectError(gl.NO_ERROR);

            bufferedLogToConsole('gl.INVALID_VALUE is generated if uniformBlockIndex is greater than or equal to the value of gl.ACTIVE_UNIFORM_BLOCKS or is not the index of an active uniform block in program.');
            gl.useProgram(program.getProgram());
            this.expectError(gl.NO_ERROR);
            params = gl.getActiveUniformBlockParameter(program.getProgram(), numActiveBlocks, gl.UNIFORM_BLOCK_BINDING);
            this.expectError(gl.INVALID_VALUE);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not one of the accepted tokens.');
            params = gl.getActiveUniformBlockParameter(program.getProgram(), 0, -1);
            this.expectError(gl.INVALID_ENUM);

            gl.useProgram(null);
        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_active_uniform_block_name', 'Invalid gl.getActiveUniformBlockName() usage', gl, function() {
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            /** @type{number} */ var length = -1;
            /** @type{number} */ var numActiveBlocks = -1;
            /** @type{string} */ var uniformBlockName;

            numActiveBlocks = /** @type{number} */ (gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORM_BLOCKS));
            bufferedLogToConsole('// gl.ACTIVE_UNIFORM_BLOCKS = ' + numActiveBlocks + ' (expected 1).');
            this.expectError(gl.NO_ERROR);

            bufferedLogToConsole('gl.INVALID_VALUE is generated if uniformBlockIndex is greater than or equal to the value of gl.ACTIVE_UNIFORM_BLOCKS or is not the index of an active uniform block in program.');
            gl.useProgram(program.getProgram());
            this.expectError(gl.NO_ERROR);
            uniformBlockName = gl.getActiveUniformBlockName(program.getProgram(), numActiveBlocks);
            this.expectError(gl.INVALID_VALUE);

            gl.useProgram(null);
        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_active_attrib', 'Invalid gl.getActiveAttrib() usage', gl, function() {
            /** @type{WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            /** @type{number} */ var numActiveAttributes = -1;

            /** @type{WebGLActiveInfo} */ var activeInfo;
            /** @type{number} */ var size = -1;
            /** @type{number} */ var type = -1;
            /** @type{string} */ var name;

            numActiveAttributes = /** @type{number} */(gl.getProgramParameter(program.getProgram(), gl.ACTIVE_ATTRIBUTES));
            bufferedLogToConsole('// gl.ACTIVE_ATTRIBUTES = ' + numActiveAttributes + ' (expected 1).');

            gl.useProgram(program.getProgram());

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

            bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater than or equal to gl.ACTIVE_ATTRIBUTES.');
            activeInfo = gl.getActiveAttrib(program.getProgram(), numActiveAttributes);
            this.expectError(gl.INVALID_VALUE);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_uniform_indices', 'Invalid gl.getUniformIndices() usage', gl, function() {
            /** @type{WebGLShader} */ var shader = gl.createShader(gl.VERTEX_SHADER);
            /** @type{gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl,gluShaderProgram.makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
            gl.useProgram(program.getProgram());
            /** @type{number} */ var numActiveBlocks = -1;
            /** @type{Array<string>} */ var uniformName = ['Block.blockVar'];
            /** @type{Array<number>} */ var uniformIndices = [-1];

            numActiveBlocks = /** @type{number} */(gl.getProgramParameter(program.getProgram(), gl.ACTIVE_UNIFORM_BLOCKS));
            bufferedLogToConsole('// gl.ACTIVE_UNIFORM_BLOCKS = ' + numActiveBlocks);
            this.expectError (gl.NO_ERROR);

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

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_vertex_attrib', 'Invalid gl.getVertexAttrib() usage', gl, function() {
            /** @type{*} */ var params;

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted value.');
            params = gl.getVertexAttrib(0, -1);
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater than or equal to gl.MAX_VERTEX_ATTRIBS.');
            /** @type{number} */ var maxVertexAttribs;
            maxVertexAttribs = /** @type{number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
            params = gl.getVertexAttrib(maxVertexAttribs, gl.VERTEX_ATTRIB_ARRAY_ENABLED);
            this.expectError(gl.INVALID_VALUE);

        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_vertex_attrib_offset', 'Invalid gl.getVertexAttribOffset() usage', gl, function() {
            /** @type{number} */ var ptr;

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted value.');
            ptr = gl.getVertexAttribOffset(0, -1);
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_VALUE is generated if index is greater than or equal to gl.MAX_VERTEX_ATTRIBS.');
            /** @type{number} */ var maxVertexAttribs;
            maxVertexAttribs = /** @type{number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
            ptr = gl.getVertexAttribOffset(maxVertexAttribs, gl.VERTEX_ATTRIB_ARRAY_POINTER);
            this.expectError(gl.INVALID_VALUE);

        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_frag_data_location', 'Invalid gl.getFragDataLocation() 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 program has not been linked.');
            gl.getFragDataLocation(program, 'gl_FragColor');
            this.expectError(gl.INVALID_OPERATION);

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

        // Enumerated state queries: Buffers

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_buffer_parameter', 'Invalid gl.getBufferParameter() usage', gl, function() {
            /** @type{number} */ var params = -1;
            /** @type{WebGLBuffer} */ var buf;
            buf = gl.createBuffer();
            gl.bindBuffer(gl.ARRAY_BUFFER, buf);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target or value is not an accepted value.');
            params = /** @type{number} */ (gl.getBufferParameter(-1, gl.BUFFER_SIZE));
            this.expectError(gl.INVALID_ENUM);
            params = /** @type{number} */ (gl.getBufferParameter(gl.ARRAY_BUFFER, -1));
            this.expectError(gl.INVALID_ENUM);
            params = /** @type{number} */ (gl.getBufferParameter(-1, -1));
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.');
            gl.bindBuffer(gl.ARRAY_BUFFER, null);
            params = /** @type{number} */ (gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE));
            this.expectError(gl.INVALID_OPERATION);

            gl.deleteBuffer(buf);
        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_framebuffer_attachment_parameter', 'Invalid gl.getFramebufferAttachmentParameter() usage', gl, function() {
            /** @type{*} */ var params;
            /** @type{WebGLFramebuffer} */ var fbo;
            /** @type{Array<WebGLRenderbuffer>} */ var rbo = [];

            fbo = gl.createFramebuffer();
            rbo[0] = gl.createRenderbuffer();
            rbo[1] = gl.createRenderbuffer();

            gl.bindFramebuffer (gl.FRAMEBUFFER, fbo);
            gl.bindRenderbuffer (gl.RENDERBUFFER, rbo[0]);
            gl.renderbufferStorage (gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 16, 16);
            gl.framebufferRenderbuffer (gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, rbo[0]);
            gl.bindRenderbuffer (gl.RENDERBUFFER, rbo[1]);
            gl.renderbufferStorage (gl.RENDERBUFFER, gl.STENCIL_INDEX8, 16, 16);
            gl.framebufferRenderbuffer (gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, rbo[1]);
            gl.checkFramebufferStatus (gl.FRAMEBUFFER);
            this.expectError (gl.NO_ERROR);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target is not one of the accepted tokens.');
            gl.getFramebufferAttachmentParameter(-1, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); // TYPE is gl.RENDERBUFFER
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not valid for the value of gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE.');
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL); // TYPE is gl.RENDERBUFFER
            this.expectError(gl.INVALID_ENUM);
            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); // TYPE is gl.FRAMEBUFFER_DEFAULT
            this.expectError(gl.INVALID_ENUM);
            gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);

            bufferedLogToConsole('gl.INVALID_OPERATION is generated if attachment is gl.DEPTH_STENCIL_ATTACHMENT and different objects are bound to the depth and stencil attachment points of target.');
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME);
            this.expectError(gl.INVALID_OPERATION);

            bufferedLogToConsole('gl.INVALID_OPERATION is generated if the value of gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is gl.NONE and pname is not gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME.');
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); // TYPE is gl.NONE
            this.expectError(gl.NO_ERROR);
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE); // TYPE is gl.NONE
            this.expectError(gl.INVALID_OPERATION);

            bufferedLogToConsole('gl.INVALID_OPERATION or gl.INVALID_ENUM is generated if attachment is not one of the accepted values for the current binding of target.');
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); // A FBO is bound so gl.BACK is invalid
            this.expectError([gl.INVALID_OPERATION, gl.INVALID_ENUM]);
            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
            gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); // Default framebuffer is bound so gl.COLOR_ATTACHMENT0 is invalid
            this.expectError([gl.INVALID_OPERATION, gl.INVALID_ENUM]);

            gl.deleteFramebuffer(fbo);
        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_renderbuffer_parameter', 'Invalid gl.getRenderbufferParameter() usage', gl, function() {
            /** @type{number} */ var params = -1;
            /** @type{WebGLRenderbuffer} */ var rbo;
            rbo = gl.createRenderbuffer();
            gl.bindRenderbuffer(gl.RENDERBUFFER, rbo);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target is not gl.RENDERBUFFER.');
            gl.getRenderbufferParameter(-1, gl.RENDERBUFFER_WIDTH);
            this.expectError(gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not one of the accepted tokens.');
            gl.getRenderbufferParameter(gl.RENDERBUFFER, -1);
            this.expectError(gl.INVALID_ENUM);

            gl.deleteRenderbuffer(rbo);
            gl.bindRenderbuffer(gl.RENDERBUFFER, null);
        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_internalformat_parameter', 'Invalid gl.getInternalformatParameter() usage', gl, function() {
            /** @type{WebGLRenderbuffer} */ var rbo = gl.createRenderbuffer();
            /** @type{WebGLFramebuffer} */ var fbo = gl.createFramebuffer();
            /** @type{WebGLTexture} */ var tex = gl.createTexture();
            gl.bindRenderbuffer(gl.RENDERBUFFER, rbo);
            gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
            gl.bindTexture(gl.TEXTURE_2D, tex);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not gl.SAMPLES or gl.NUM_SAMPLE_COUNTS.');
            gl.getInternalformatParameter (gl.RENDERBUFFER, gl.RGBA8, -1);
            this.expectError (gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if internalformat is not color-, depth-, or stencil-renderable.');
            gl.getInternalformatParameter (gl.RENDERBUFFER, gl.RG8_SNORM, gl.NUM_SAMPLE_COUNTS);
            this.expectError (gl.INVALID_ENUM);
            gl.getInternalformatParameter (gl.RENDERBUFFER, gl.COMPRESSED_RGB8_ETC2, gl.NUM_SAMPLE_COUNTS);
            this.expectError (gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target is not gl.RENDERBUFFER.');
            gl.getInternalformatParameter (-1, gl.RGBA8, gl.NUM_SAMPLE_COUNTS);
            this.expectError (gl.INVALID_ENUM);
            gl.getInternalformatParameter (gl.FRAMEBUFFER, gl.RGBA8, gl.NUM_SAMPLE_COUNTS);
            this.expectError (gl.INVALID_ENUM);
            gl.getInternalformatParameter (gl.TEXTURE_2D, gl.RGBA8, gl.NUM_SAMPLE_COUNTS);
            this.expectError (gl.INVALID_ENUM);

            gl.deleteRenderbuffer(rbo);
            gl.deleteFramebuffer(fbo);
            gl.deleteTexture(tex);

        }));

        // Query object queries

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_query', 'Invalid gl.getQuery() usage', gl, function() {
            /** @type{number} */ var params = -1;

            bufferedLogToConsole('gl.INVALID_ENUM is generated if target or pname is not an accepted value.');
            gl.getQuery (gl.ANY_SAMPLES_PASSED, -1);
            this.expectError (gl.INVALID_ENUM);
            gl.getQuery (-1, gl.CURRENT_QUERY);
            this.expectError (gl.INVALID_ENUM);
            gl.getQuery (-1, -1);
            this.expectError (gl.INVALID_ENUM);

        }));

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_query_parameter', 'Invalid gl.getQueryParameter() usage', gl, function() {

            /** @type{WebGLQuery} */ var id;
            id = gl.createQuery();

            bufferedLogToConsole('An exception is thrown if the query object is null.');
            this.expectThrowNoError(function() {
                gl.getQueryParameter (null, gl.QUERY_RESULT_AVAILABLE);
            });

            bufferedLogToConsole('// Note: ' + id + ' is not a query object yet, since it hasn\'t been used by gl.beginQuery');
            gl.getQueryParameter (id, gl.QUERY_RESULT_AVAILABLE);
            this.expectError (gl.INVALID_OPERATION);

            gl.beginQuery (gl.ANY_SAMPLES_PASSED, id);
            gl.endQuery (gl.ANY_SAMPLES_PASSED);

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not an accepted value.');
            gl.getQueryParameter (id, -1);
            this.expectError (gl.INVALID_ENUM);

            bufferedLogToConsole('gl.INVALID_OPERATION is generated if id is the name of a currently active query object.');
            gl.beginQuery (gl.ANY_SAMPLES_PASSED, id);
            this.expectError (gl.NO_ERROR);
            gl.getQueryParameter (id, gl.QUERY_RESULT_AVAILABLE);
            this.expectError (gl.INVALID_OPERATION);
            gl.endQuery (gl.ANY_SAMPLES_PASSED);
            this.expectError (gl.NO_ERROR);

            gl.deleteQuery(id);
        }));

        // Sync object queries

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('get_sync_parameter', 'Invalid gl.getSyncParameter() usage', gl, function() {
            /** @type{WebGLSync} */ var sync;

            bufferedLogToConsole('An exception is thrown if sync is null.');
            this.expectThrowNoError(function() {
                gl.getSyncParameter (null, gl.OBJECT_TYPE);
            });

            bufferedLogToConsole('gl.INVALID_ENUM is generated if pname is not one of the accepted tokens.');
            sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
            this.expectError (gl.NO_ERROR);
            gl.getSyncParameter (sync, -1);
            this.expectError (gl.INVALID_ENUM);

        }));

        // Enumerated boolean state queries

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_enabled', 'Invalid gl.isEnabled() usage', gl, function() {
            bufferedLogToConsole('gl.INVALID_ENUM is generated if cap is not an accepted value.');
            gl.isEnabled(-1);
            this.expectError(gl.INVALID_ENUM);
            gl.isEnabled(gl.TRIANGLES);
            this.expectError(gl.INVALID_ENUM);

        }));

        // Named Object Usage

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_buffer', 'Invalid gl.isBuffer() usage', gl, function() {
            /** @type{WebGLBuffer} */ var buffer;
            /** @type{boolean} */ var isBuffer;

            bufferedLogToConsole('A name returned by glGenBuffers, but not yet associated with a buffer object by calling glBindBuffer, is not the name of a buffer object.');
            isBuffer = gl.isBuffer(buffer);
            assertMsgOptions(!isBuffer, 'Got invalid boolean value', false, true);

            buffer = gl.createBuffer();
            isBuffer = gl.isBuffer(buffer);
            assertMsgOptions(!isBuffer, 'Got invalid boolean value', false, true);

            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
            isBuffer = gl.isBuffer(buffer);
            assertMsgOptions(isBuffer, 'Got invalid boolean value', false, true);

            gl.bindBuffer(gl.ARRAY_BUFFER, null);
            gl.deleteBuffer(buffer);
            isBuffer = gl.isBuffer(buffer);
            assertMsgOptions(!isBuffer, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_framebuffer', 'Invalid gl.isFramebuffer() usage', gl, function() {
            /** @type{WebGLFramebuffer} */ var fbo;
            /** @type{boolean} */ var isFbo;

            bufferedLogToConsole('A name returned by glGenFramebuffers, but not yet bound through a call to gl.bindFramebuffer is not the name of a framebuffer object.');
            isFbo = gl.isFramebuffer(fbo);
            assertMsgOptions(!isFbo, 'Got invalid boolean value', false, true);

            fbo = gl.createFramebuffer();
            isFbo = gl.isFramebuffer(fbo);
            assertMsgOptions(!isFbo, 'Got invalid boolean value', false, true);

            gl.bindFramebuffer (gl.FRAMEBUFFER, fbo);
            isFbo = gl.isFramebuffer(fbo);
            assertMsgOptions(isFbo, 'Got invalid boolean value', false, true);

            gl.bindFramebuffer (gl.FRAMEBUFFER, null);
            gl.deleteFramebuffer(fbo);
            isFbo = gl.isFramebuffer(fbo);
            assertMsgOptions(!isFbo, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_program', 'Invalid gl.isProgram() usage', gl, function() {
            /** @type{WebGLProgram} */ var program;
            /** @type{boolean} */ var isProgram;

            bufferedLogToConsole('A name created with gl.createProgram, and not yet deleted with glDeleteProgram is a name of a program object.');
            isProgram = gl.isProgram(program);
            assertMsgOptions(!isProgram, 'Got invalid boolean value', false, true);

            program = gl.createProgram();
            isProgram = gl.isProgram(program);
            assertMsgOptions(isProgram, 'Got invalid boolean value', false, true);

            gl.deleteProgram(program);
            isProgram = gl.isProgram(program);
            assertMsgOptions(!isProgram, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_renderbuffer', 'Invalid gl.isRenderbuffer() usage', gl, function() {
            /** @type{WebGLRenderbuffer} */ var rbo;
            /** @type{boolean} */ var isRbo;

            bufferedLogToConsole('A name returned by glGenRenderbuffers, but not yet bound through a call to gl.bindRenderbuffer or gl.framebufferRenderbuffer is not the name of a renderbuffer object.');
            isRbo = gl.isRenderbuffer(rbo);
            assertMsgOptions(!isRbo, 'Got invalid boolean value', false, true);

            rbo = gl.createRenderbuffer();
            isRbo = gl.isRenderbuffer(rbo);
            assertMsgOptions(!isRbo, 'Got invalid boolean value', false, true);

            gl.bindRenderbuffer (gl.RENDERBUFFER, rbo);
            isRbo = gl.isRenderbuffer(rbo);
            assertMsgOptions(isRbo, 'Got invalid boolean value', false, true);

            gl.bindRenderbuffer (gl.RENDERBUFFER, null);
            gl.deleteRenderbuffer(rbo);
            isRbo = gl.isRenderbuffer(rbo);
            assertMsgOptions(!isRbo, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_shader', 'Invalid gl.isShader() usage', gl, function() {
            /** @type{WebGLShader} */ var shader;
            /** @type{boolean} */ var isShader;

            bufferedLogToConsole('A name created with glCreateShader, and not yet deleted with glDeleteShader is a name of a shader object.');
            isShader = gl.isProgram(shader);
            assertMsgOptions(!isShader, 'Got invalid boolean value', false, true);

            shader = gl.createShader(gl.VERTEX_SHADER);
            isShader = gl.isShader(shader);
            assertMsgOptions(isShader, 'Got invalid boolean value', false, true);

            gl.deleteShader (shader);
            isShader = gl.isShader(shader);
            assertMsgOptions(!isShader, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_texture', 'Invalid gl.isTexture() usage', gl, function() {
            /** @type{WebGLTexture} */ var texture;
            /** @type{boolean} */ var isTexture;

            bufferedLogToConsole('A name returned by glGenTextures, but not yet bound through a call to glBindTexture is not the name of a texture.');
            isTexture = gl.isTexture(texture);
            assertMsgOptions(!isTexture, 'Got invalid boolean value', false, true);

            texture = gl.createTexture();
            isTexture = gl.isTexture(texture);
            assertMsgOptions(!isTexture, 'Got invalid boolean value', false, true);

            gl.bindTexture (gl.TEXTURE_2D, texture);
            isTexture = gl.isTexture(texture);
            assertMsgOptions(isTexture, 'Got invalid boolean value', false, true);

            gl.bindTexture (gl.TEXTURE_2D, null);
            gl.deleteTexture(texture);
            isTexture = gl.isTexture(texture);
            assertMsgOptions(!isTexture, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_query', 'Invalid gl.isQuery() usage', gl, function() {
            /** @type{WebGLQuery} */ var query;
            /** @type{boolean} */ var isQuery;

            bufferedLogToConsole('A name returned by glGenQueries, but not yet associated with a query object by calling gl.beginQuery, is not the name of a query object.');
            isQuery = gl.isQuery(query);
            assertMsgOptions(!isQuery, 'Got invalid boolean value', false, true);

            query = gl.createQuery();
            isQuery = gl.isQuery(query);
            assertMsgOptions(!isQuery, 'Got invalid boolean value', false, true);

            gl.beginQuery (gl.ANY_SAMPLES_PASSED, query);
            isQuery = gl.isQuery(query);
            assertMsgOptions(isQuery, 'Got invalid boolean value', false, true);

            gl.endQuery (gl.ANY_SAMPLES_PASSED);
            gl.deleteQuery (query);
            isQuery = gl.isQuery(query);
            assertMsgOptions(!isQuery, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_sampler', 'Invalid gl.isSampler() usage', gl, function() {
            /** @type{WebGLSampler} */ var sampler;
            /** @type{boolean} */ var isSampler;

            bufferedLogToConsole('A name returned by glGenSamplers is the name of a sampler object.');
            isSampler = gl.isSampler(sampler);
            assertMsgOptions(!isSampler, 'Got invalid boolean value', false, true);

            sampler = gl.createSampler();
            isSampler = gl.isSampler(sampler);
            assertMsgOptions(isSampler, 'Got invalid boolean value', false, true);

            gl.bindSampler(0, sampler);
            isSampler = gl.isSampler(sampler);
            assertMsgOptions(isSampler, 'Got invalid boolean value', false, true);

            gl.deleteSampler(sampler);
            isSampler = gl.isSampler(sampler);
            assertMsgOptions(!isSampler, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_sync', 'Invalid gl.isSync() usage', gl, function() {
            /** @type{WebGLSync} */ var sync;
            /** @type{boolean} */ var isSync;

            bufferedLogToConsole('A name returned by gl.fenceSync is the name of a sync object.');
            isSync = gl.isSync(sync);
            assertMsgOptions(!isSync, 'Got invalid boolean value', false, true);

            sync = gl.fenceSync (gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
            isSync = gl.isSync(sync);
            assertMsgOptions(isSync, 'Got invalid boolean value', false, true);

            gl.deleteSync (sync);
            isSync = gl.isSync(sync);
            assertMsgOptions(!isSync, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_transform_feedback', 'Invalid gl.isTransformFeedback() usage', gl, function() {
            /** @type{WebGLTransformFeedback} */ var tf;
            /** @type{boolean} */ var isTF;

            bufferedLogToConsole('A name returned by glGenTransformFeedbacks, but not yet bound using glBindTransformFeedback, is not the name of a transform feedback object.');
            isTF = gl.isTransformFeedback(tf);
            assertMsgOptions(!isTF, 'Got invalid boolean value', false, true);

            tf = gl.createTransformFeedback();
            isTF = gl.isTransformFeedback(tf);
            assertMsgOptions(!isTF, 'Got invalid boolean value', false, true);

            gl.bindTransformFeedback (gl.TRANSFORM_FEEDBACK, tf);
            isTF = gl.isTransformFeedback(tf);
            assertMsgOptions(isTF, 'Got invalid boolean value', false, true);

            gl.bindTransformFeedback (gl.TRANSFORM_FEEDBACK, null);
            gl.deleteTransformFeedback (tf);
            isTF = gl.isTransformFeedback(tf);
            assertMsgOptions(!isTF, 'Got invalid boolean value', false, true);

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

        testGroup.addChild(new es3fApiCase.ApiCaseCallback('is_vertex_array', 'Invalid gl.isVertexArray() usage', gl, function() {
            /** @type{WebGLVertexArrayObject} */ var vao;
            /** @type{boolean} */ var isVao;

            bufferedLogToConsole('A name returned by glGenVertexArrays, but not yet bound using glBindVertexArray, is not the name of a vertex array object.');
            isVao = gl.isVertexArray(vao);
            assertMsgOptions(!isVao, 'Got invalid boolean value', false, true);

            vao = gl.createVertexArray();
            isVao = gl.isVertexArray(vao);
            assertMsgOptions(!isVao, 'Got invalid boolean value', false, true);

            gl.bindVertexArray (vao);
            isVao = gl.isVertexArray(vao);
            assertMsgOptions(isVao, 'Got invalid boolean value', false, true);

            gl.bindVertexArray (null);
            gl.deleteVertexArray (vao);
            isVao = gl.isVertexArray(vao);
            assertMsgOptions(!isVao, 'Got invalid boolean value', false, true);

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

    /**
    * @param {WebGL2RenderingContext} gl
    */
    es3fNegativeStateApiTests.run = function(gl) {
        var testName = 'state';
        var testDescription = 'Negative GL State API Cases';
        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 {
            es3fNegativeStateApiTests.init(gl);
            tcuTestCase.runner.runCallback(tcuTestCase.runTestCases);
        } catch (err) {
            bufferedLogToConsole(err);
            tcuTestCase.runner.terminate();
        }
    };

});