| /*------------------------------------------------------------------------- |
| * 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(); |
| } |
| }; |
| |
| }); |
