Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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();
}
};
});