diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fNegativeShaderApiTests.js | 1195 |
1 files changed, 1195 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fNegativeShaderApiTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fNegativeShaderApiTests.js new file mode 100644 index 0000000000..6e48dab60d --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fNegativeShaderApiTests.js @@ -0,0 +1,1195 @@ +/*------------------------------------------------------------------------- + * 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(); + } + }; +}); |