diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderStateQueryTests.js | 2205 |
1 files changed, 2205 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderStateQueryTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderStateQueryTests.js new file mode 100644 index 0000000000..1a2859f249 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderStateQueryTests.js @@ -0,0 +1,2205 @@ +/*------------------------------------------------------------------------- + * 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.es3fShaderStateQueryTests'); +goog.require('framework.common.tcuMatrix'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('functional.gles3.es3fApiCase'); +goog.require('modules.shared.glsStateQuery'); + +goog.scope(function() { +var es3fShaderStateQueryTests = functional.gles3.es3fShaderStateQueryTests; +var tcuTestCase = framework.common.tcuTestCase; +var glsStateQuery = modules.shared.glsStateQuery; +var es3fApiCase = functional.gles3.es3fApiCase; +var deRandom = framework.delibs.debase.deRandom; +var tcuMatrix = framework.common.tcuMatrix; + +var setParentClass = function(child, parent) { + child.prototype = Object.create(parent.prototype); + child.prototype.constructor = child; +}; + +var commonTestVertSource = '#version 300 es\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0);\n' + + '}\n'; +var commonTestFragSource = '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;\n' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + +var brokenShader = '#version 300 es\n' + + 'broken, this should not compile!\n' + + '\n'; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ShaderTypeCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ShaderTypeCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ShaderTypeCase.prototype.test = function() { + var shaderTypes = [gl.VERTEX_SHADER, gl.FRAGMENT_SHADER]; + for (var ndx = 0; ndx < shaderTypes.length; ++ndx) { + var shader = gl.createShader(shaderTypes[ndx]); + var result = glsStateQuery.verifyShader(shader, gl.SHADER_TYPE, shaderTypes[ndx]); + this.check(result, 'Incorrect shader type'); + gl.deleteShader(shader); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ShaderCompileStatusCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ShaderCompileStatusCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ShaderCompileStatusCase.prototype.test = function() { + var result; + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + result = glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, false); + this.check(result, 'Vertex shader compilation status should be false'); + result = glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, false); + this.check(result, 'Fragment shader compilation status should be false'); + + gl.shaderSource(shaderVert, commonTestVertSource); + gl.shaderSource(shaderFrag, commonTestFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + result = glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true); + this.check(result, 'Vertex shader compilation status should be true'); + result = glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true); + this.check(result, 'Fragment shader compilation status should be true'); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ShaderInfoLogCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ShaderInfoLogCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ShaderInfoLogCase.prototype.test = function() { + var shader = gl.createShader(gl.VERTEX_SHADER); + var log = gl.getShaderInfoLog(shader); + this.check(log === ''); + + gl.shaderSource(shader, brokenShader); + gl.compileShader(shader); + + log = gl.getShaderInfoLog(shader); + this.check(log === null || typeof log === 'string'); + + gl.deleteShader(shader); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ShaderSourceCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ShaderSourceCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ShaderSourceCase.prototype.test = function() { + var shader = gl.createShader(gl.VERTEX_SHADER); + this.check(gl.getShaderSource(shader) === ''); + + gl.shaderSource(shader, brokenShader); + this.check(gl.getShaderSource(shader) === brokenShader); + + gl.deleteShader(shader); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.DeleteStatusCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.DeleteStatusCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.DeleteStatusCase.prototype.test = function() { + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, commonTestVertSource); + gl.shaderSource(shaderFrag, commonTestFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true)); + + var shaderProg = gl.createProgram(); + gl.attachShader(shaderProg, shaderVert); + gl.attachShader(shaderProg, shaderFrag); + gl.linkProgram(shaderProg); + + this.check(glsStateQuery.verifyProgram(shaderProg, gl.LINK_STATUS, true)); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.DELETE_STATUS, false)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.DELETE_STATUS, false)); + this.check(glsStateQuery.verifyProgram(shaderProg, gl.DELETE_STATUS, false)); + + gl.useProgram(shaderProg); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(shaderProg); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.DELETE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.DELETE_STATUS, true)); + this.check(glsStateQuery.verifyProgram(shaderProg, gl.DELETE_STATUS, true)); + + gl.useProgram(null); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.CurrentVertexAttribInitialCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribInitialCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.CurrentVertexAttribInitialCase.prototype.test = function() { + var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS)); + var initial = new Float32Array([0, 0, 0, 1]); + // initial + + for (var index = 0; index < attribute_count; ++index) { + var attrib = gl.getVertexAttrib(index, gl.CURRENT_VERTEX_ATTRIB); + this.check(glsStateQuery.compare(attrib, initial), 'Initial attrib value should be [0, 0, 0, 1]'); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.CurrentVertexAttribFloatCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribFloatCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.CurrentVertexAttribFloatCase.prototype.test = function() { + var rnd = new deRandom.Random(0xabcdef); + + var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS)); + + // test write float/read float + + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getFloat(-64000, 64000); + var y = rnd.getFloat(-64000, 64000); + var z = rnd.getFloat(-64000, 64000); + var w = rnd.getFloat(-64000, 64000); + + gl.vertexAttrib4f(index, x, y, z, w); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w]))); + } + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getFloat(-64000, 64000); + var y = rnd.getFloat(-64000, 64000); + var z = rnd.getFloat(-64000, 64000); + var w = 1.0; + + gl.vertexAttrib3f(index, x, y, z); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w]))); + } + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getFloat(-64000, 64000); + var y = rnd.getFloat(-64000, 64000); + var z = 0.0; + var w = 1.0; + + gl.vertexAttrib2f(index, x, y); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w]))); + } + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getFloat(-64000, 64000); + var y = 0.0; + var z = 0.0; + var w = 1.0; + + gl.vertexAttrib1f(index, x); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Float32Array([x, y, z, w]))); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.CurrentVertexAttribIntCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribIntCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.CurrentVertexAttribIntCase.prototype.test = function() { + var rnd = new deRandom.Random(0xabcdef); + + var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS)); + + // test write float/read float + + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getInt(-64000, 64000); + var y = rnd.getInt(-64000, 64000); + var z = rnd.getInt(-64000, 64000); + var w = rnd.getInt(-64000, 64000); + + gl.vertexAttribI4i(index, x, y, z, w); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Int32Array([x, y, z, w]))); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.CurrentVertexAttribUintCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.CurrentVertexAttribUintCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.CurrentVertexAttribUintCase.prototype.test = function() { + var rnd = new deRandom.Random(0xabcdef); + + var attribute_count = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS)); + + // test write float/read float + + for (var index = 0; index < attribute_count; ++index) { + var x = rnd.getInt(0, 64000); + var y = rnd.getInt(0, 64000); + var z = rnd.getInt(0, 64000); + var w = rnd.getInt(0, 64000); + + gl.vertexAttribI4ui(index, x, y, z, w); + this.check(glsStateQuery.verifyCurrentVertexAttrib(index, new Uint32Array([x, y, z, w]))); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramInfoLogCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramInfoLogCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramInfoLogCase.prototype.test = function() { + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, brokenShader); + gl.compileShader(shaderVert); + gl.shaderSource(shaderFrag, brokenShader); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + var log = gl.getProgramInfoLog(program); + this.check(log === null || typeof log === 'string'); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramValidateStatusCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramValidateStatusCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramValidateStatusCase.prototype.test = function() { + // test validate ok + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, commonTestVertSource); + gl.shaderSource(shaderFrag, commonTestFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true)); + + gl.validateProgram(program); + this.check(glsStateQuery.verifyProgram(program, gl.VALIDATE_STATUS, true)); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); + + // test with broken shader + shaderVert = gl.createShader(gl.VERTEX_SHADER); + shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, commonTestVertSource); + gl.shaderSource(shaderFrag, brokenShader); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, false)); + this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, false)); + + gl.validateProgram(program); + this.check(glsStateQuery.verifyProgram(program, gl.VALIDATE_STATUS, false)); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramAttachedShadersCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramAttachedShadersCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramAttachedShadersCase.prototype.test = function() { + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, commonTestVertSource); + gl.shaderSource(shaderFrag, commonTestFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + // check ATTACHED_SHADERS + + var program = gl.createProgram(); + this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 0)); + + gl.attachShader(program, shaderVert); + this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 1)); + + gl.attachShader(program, shaderFrag); + this.check(glsStateQuery.verifyProgram(program, gl.ATTACHED_SHADERS, 2)); + + // check GetAttachedShaders + var shaders = gl.getAttachedShaders(program); + this.check(glsStateQuery.compare(shaders, [shaderVert, shaderFrag])); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramActiveUniformNameCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramActiveUniformNameCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramActiveUniformNameCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform highp float uniformNameWithLength23;\n' + + 'uniform highp vec2 uniformVec2;\n' + + 'uniform highp mat4 uniformMat4;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0) + vec4(uniformNameWithLength23) + vec4(uniformVec2.x) + vec4(uniformMat4[2][3]);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_UNIFORMS, 3)); + + var uniformNames = [ + 'uniformNameWithLength23', + 'uniformVec2', + 'uniformMat4' + ]; + + var indices = gl.getUniformIndices(program, uniformNames); + + // check names + for (var ndx = 0; ndx < uniformNames.length; ++ndx) { + var index = indices[ndx]; + var uniform = gl.getActiveUniform(program, index); + + this.check(glsStateQuery.compare(uniform.name, uniformNames[ndx])); + } + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); + +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramUniformCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramUniformCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramUniformCase.prototype.test = function() { + var uniformTypes = [ + ['float', '', 'highp', '', 'uniformValue', gl.FLOAT, 1, false], + ['float[2]', '', 'highp', '', 'uniformValue[1]', gl.FLOAT, 2, false], + ['vec2', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC2, 1, false], + ['vec3', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC3, 1, false], + ['vec4', '', 'highp', '', 'uniformValue.x', gl.FLOAT_VEC4, 1, false], + ['int', '', 'highp', '', 'float(uniformValue)', gl.INT, 1, false], + ['ivec2', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC2, 1, false], + ['ivec3', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC3, 1, false], + ['ivec4', '', 'highp', '', 'float(uniformValue.x)', gl.INT_VEC4, 1, false], + ['uint', '', 'highp', '', 'float(uniformValue)', gl.UNSIGNED_INT, 1, false], + ['uvec2', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC2, 1, false], + ['uvec3', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC3, 1, false], + ['uvec4', '', 'highp', '', 'float(uniformValue.x)', gl.UNSIGNED_INT_VEC4, 1, false], + ['bool', '', '', '', 'float(uniformValue)', gl.BOOL, 1, false], + ['bvec2', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC2, 1, false], + ['bvec3', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC3, 1, false], + ['bvec4', '', '', '', 'float(uniformValue.x)', gl.BOOL_VEC4, 1, false], + ['mat2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2, 1, false], + ['mat3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3, 1, false], + ['mat4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4, 1, false], + ['mat2x3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2x3, 1, false], + ['mat2x4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT2x4, 1, false], + ['mat3x2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3x2, 1, false], + ['mat3x4', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT3x4, 1, false], + ['mat4x2', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4x2, 1, false], + ['mat4x3', '', 'highp', '', 'float(uniformValue[0][0])', gl.FLOAT_MAT4x3, 1, false], + ['sampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D, 1, false], + ['sampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_3D, 1, false], + ['samplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_CUBE, 1, false], + ['sampler2DShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_SHADOW, 1, false], + ['sampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_ARRAY, 1, false], + ['sampler2DArrayShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_2D_ARRAY_SHADOW, 1, false], + ['samplerCubeShadow', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.SAMPLER_CUBE_SHADOW, 1, false], + ['isampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_2D, 1, false], + ['isampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_3D, 1, false], + ['isamplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_CUBE, 1, false], + ['isampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.INT_SAMPLER_2D_ARRAY, 1, false], + ['usampler2D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_2D, 1, false], + ['usampler3D', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_3D, 1, false], + ['usamplerCube', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_CUBE, 1, false], + ['usampler2DArray', '', 'highp', '', 'float(textureSize(uniformValue,0).r)', gl.UNSIGNED_INT_SAMPLER_2D_ARRAY, 1, false] + ]; + + var vertSource = + '#version 300 es\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + var program = gl.createProgram(); + + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + + gl.shaderSource(shaderVert, vertSource); + gl.compileShader(shaderVert); + + for (var ndx = 0; ndx < uniformTypes.length; ++ndx) { + var declaration = uniformTypes[ndx][0]; + var postDeclaration = uniformTypes[ndx][1]; + var precision = uniformTypes[ndx][2]; + var layout = uniformTypes[ndx][3]; + var getter = uniformTypes[ndx][4]; + var type = uniformTypes[ndx][5]; + var size = uniformTypes[ndx][6]; + var isRowMajor = uniformTypes[ndx][7]; + bufferedLogToConsole('Verify type of ' + declaration + ' variable' + postDeclaration); + + // gen fragment shader + + var frag = ''; + frag += '#version 300 es\n'; + frag += layout + 'uniform ' + precision + ' ' + declaration + ' uniformValue' + postDeclaration + ';\n'; + frag += 'layout(location = 0) out mediump vec4 fragColor;\n'; + frag += 'void main (void)\n'; + frag += '{\n'; + frag += ' fragColor = vec4(' + getter + ');\n'; + frag += '}\n'; + + gl.shaderSource(shaderFrag, frag); + + // compile & link + + gl.compileShader(shaderFrag); + gl.linkProgram(program); + + // test + if (this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true), 'Program link fail' + gl.getProgramInfoLog(program))) { + var indices = gl.getUniformIndices(program, ['uniformValue']); + var info_type = gl.getActiveUniforms(program, indices, gl.UNIFORM_TYPE)[0]; + var info_size = gl.getActiveUniforms(program, indices, gl.UNIFORM_SIZE)[0]; + var info_is_row_major = gl.getActiveUniforms(program, indices, gl.UNIFORM_IS_ROW_MAJOR)[0]; + this.check(glsStateQuery.compare(info_size, size)); + this.check(glsStateQuery.compare(info_type, type)); + this.check(glsStateQuery.compare(info_is_row_major, isRowMajor)); + } + } + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n' + + 'uniform shortUniformBlockName {highp vec2 vector2;highp vec4 vector4;} shortUniformInstanceName;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = shortUniformInstanceName.vector4 + vec4(longlongUniformInstanceName.vector2.x) + vec4(shortUniformInstanceName.vector2.x);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(longlongUniformInstanceName.vector2.y);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyProgram(program, gl.LINK_STATUS, true)); + + this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_UNIFORM_BLOCKS, 2)); + + var longlongUniformBlockIndex = gl.getUniformBlockIndex(program, 'longlongUniformBlockName'); + var shortUniformBlockIndex = gl.getUniformBlockIndex(program, 'shortUniformBlockName'); + + var uniformNames = [ + 'longlongUniformBlockName.vector2', + 'shortUniformBlockName.vector2', + 'shortUniformBlockName.vector4' + ]; + + // test UNIFORM_BLOCK_INDEX + + var uniformIndices = gl.getUniformIndices(program, uniformNames); + + var uniformsBlockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX); + this.check(uniformsBlockIndices[0] == longlongUniformBlockIndex && + uniformsBlockIndices[1] == shortUniformBlockIndex && + uniformsBlockIndices[2] == shortUniformBlockIndex, + 'Expected [' + longlongUniformBlockIndex + ", " + shortUniformBlockIndex + ", " + shortUniformBlockIndex + ']; got ' + + uniformsBlockIndices[0] + ", " + uniformsBlockIndices[1] + ", " + uniformsBlockIndices[2] + "]"); + + // test UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER & UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER + + this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, true)); + this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, true)); + this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, true)); + this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, false)); + + // test UNIFORM_BLOCK_ACTIVE_UNIFORMS + + this.check(glsStateQuery.verifyActiveUniformBlock(program, longlongUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, 1)); + this.check(glsStateQuery.verifyActiveUniformBlock(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, 2)); + + // test UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES + + var shortUniformBlockIndices = gl.getActiveUniformBlockParameter(program, shortUniformBlockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES); + this.check(shortUniformBlockIndices.length == 2, 'Expected 2 indices; got ' + shortUniformBlockIndices.length); + + this.check(glsStateQuery.compare(shortUniformBlockIndices, new Uint32Array([uniformIndices[1], uniformIndices[2]])) || + glsStateQuery.compare(shortUniformBlockIndices, new Uint32Array([uniformIndices[2], uniformIndices[1]])), + 'Expected { ' + uniformIndices[1] +', ' + uniformIndices[2] + + '}; got {' + shortUniformBlockIndices[0] + ', ' + shortUniformBlockIndices[1] + '}'); + + // check block names + + var name = gl.getActiveUniformBlockName(program, longlongUniformBlockIndex); + this.check(name == "longlongUniformBlockName", 'Wrong uniform block name, expected longlongUniformBlockName; got ' + name); + name = gl.getActiveUniformBlockName(program, shortUniformBlockIndex) + this.check(name == "shortUniformBlockName", 'Wrong uniform block name, expected shortUniformBlockName; got ' + name); + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.TransformFeedbackCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.TransformFeedbackCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.TransformFeedbackCase.prototype.test = function() { + var transformFeedbackTestVertSource = + '#version 300 es\n' + + 'out highp vec4 tfOutput2withLongName;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0);\n' + + ' tfOutput2withLongName = vec4(0.0);\n' + + '}\n'; + var transformFeedbackTestFragSource = + '#version 300 es\n' + + 'layout(location = 0) out highp vec4 fragColor;\n' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + var shaderProg = gl.createProgram(); + + this.check(glsStateQuery.verifyProgram(shaderProg, gl.TRANSFORM_FEEDBACK_BUFFER_MODE, gl.INTERLEAVED_ATTRIBS)); + + gl.shaderSource(shaderVert, transformFeedbackTestVertSource); + gl.shaderSource(shaderFrag, transformFeedbackTestFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + this.check(glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true)); + this.check(glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true)); + + gl.attachShader(shaderProg, shaderVert); + gl.attachShader(shaderProg, shaderFrag); + + // check TRANSFORM_FEEDBACK_BUFFER_MODE + + var transform_feedback_outputs = ['gl_Position', 'tfOutput2withLongName']; + var bufferModes = [gl.SEPARATE_ATTRIBS, gl.INTERLEAVED_ATTRIBS]; + + for (var ndx = 0; ndx < bufferModes.length; ++ndx) { + gl.transformFeedbackVaryings(shaderProg, transform_feedback_outputs, bufferModes[ndx]); + gl.linkProgram(shaderProg); + + this.check(glsStateQuery.verifyProgram(shaderProg, gl.LINK_STATUS, true)); + this.check(glsStateQuery.verifyProgram(shaderProg, gl.TRANSFORM_FEEDBACK_BUFFER_MODE, bufferModes[ndx])); + } + + // check varyings + var varyings = /** @type {number} */ (gl.getProgramParameter(shaderProg, gl.TRANSFORM_FEEDBACK_VARYINGS)); + this.check(varyings === 2); + + for (var index = 0; index < varyings; ++index) { + var info = gl.getTransformFeedbackVarying(shaderProg, index); + this.check(glsStateQuery.compare(info.type, gl.FLOAT_VEC4)); + this.check(glsStateQuery.compare(info.size, 1)); + this.check(glsStateQuery.compare(info.name, transform_feedback_outputs[index])); + } + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(shaderProg); + + // TODO(kbr): this test is failing and leaving an error in the GL + // state, causing later tests to fail. Clear the error state for + // the time being. + while (gl.getError() != gl.NO_ERROR) {} +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.ActiveAttributesCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.ActiveAttributesCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.ActiveAttributesCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'in highp vec2 longInputAttributeName;\n' + + 'in highp vec2 shortName;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = longInputAttributeName.yxxy + shortName.xyxy;\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + + this.check(glsStateQuery.verifyProgram(program, gl.ACTIVE_ATTRIBUTES, 2)); + + var attribNames = [ + 'longInputAttributeName', + 'shortName' + ]; + // check names + for (var attributeNdx = 0; attributeNdx < 2; ++attributeNdx) { + var info = gl.getActiveAttrib(program, attributeNdx); + this.check(glsStateQuery.compare(info.name, attribNames[0]) || glsStateQuery.compare(info.name, attribNames[1])); + } + + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeSizeCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeSizeCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeSizeCase.prototype.test = function() { + var pointers = [ + // size test + [4, gl.FLOAT, 0, false, 0], + [3, gl.FLOAT, 0, false, 0], + [2, gl.FLOAT, 0, false, 0], + [1, gl.FLOAT, 0, false, 0], + [4, gl.INT, 0, false, 0], + [3, gl.INT, 0, false, 0], + [2, gl.INT, 0, false, 0], + [1, gl.INT, 0, false, 0] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[ndx][0])); + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, 4)); + + // set vao 0 to some value + gl.vertexAttribPointer(0, pointers[0][0], pointers[0][1], pointers[0][3], pointers[0][2], 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, pointers[1][0], pointers[1][1], pointers[1][3], pointers[1][2], 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[1][0])); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE, pointers[0][0])); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeTypeCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeTypeCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeTypeCase.prototype.test = function() { + var pointers = [ + // type test + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.FLOAT, 0, false, 0], + [1, gl.HALF_FLOAT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0], + [4, gl.INT_2_10_10_10_REV, 0, false, 0], + [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, pointers[ndx][1])); + } + + var pointersI = [ + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0] + ]; + + for (var ndx = 0; ndx < pointersI.length; ++ndx) { + gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, pointersI[ndx][1])); + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.FLOAT)); + + // set vao 0 to some value + gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, 1, gl.SHORT, false, 0, 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.SHORT)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE, gl.FLOAT)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeStrideCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeStrideCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeStrideCase.prototype.test = function() { + var pointers = [ + [1, gl.FLOAT, 0, 0, gl.NO_ERROR], + [1, gl.FLOAT, 1, 0, gl.INVALID_OPERATION], + [1, gl.FLOAT, 4, 0, gl.NO_ERROR], + [1, gl.HALF_FLOAT, 0, 0, gl.NO_ERROR], + [1, gl.HALF_FLOAT, 1, 0, gl.INVALID_OPERATION], + [1, gl.HALF_FLOAT, 4, 0, gl.NO_ERROR] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], false, pointers[ndx][2], pointers[ndx][3]); + this.expectError(pointers[ndx][4]); + if (pointers[ndx][4] == gl.NO_ERROR) { + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, pointers[ndx][2])); + } + } + + var pointersI = [ + [1, gl.INT, 0, 0, gl.NO_ERROR], + [1, gl.INT, 1, 0, gl.INVALID_OPERATION], + [1, gl.INT, 4, 0, gl.NO_ERROR], + [4, gl.UNSIGNED_BYTE, 0, 0, gl.NO_ERROR], + [4, gl.UNSIGNED_BYTE, 1, 0, gl.NO_ERROR], + [4, gl.UNSIGNED_BYTE, 4, 0, gl.NO_ERROR], + [2, gl.SHORT, 0, 0, gl.NO_ERROR], + [2, gl.SHORT, 1, 0, gl.INVALID_OPERATION], + [2, gl.SHORT, 4, 0, gl.NO_ERROR] + ]; + + for (var ndx = 0; ndx < pointersI.length; ++ndx) { + gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][3]); + this.expectError(pointersI[ndx][4]); + if (pointersI[ndx][4] == gl.NO_ERROR) { + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, pointersI[ndx][2])); + } + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 0)); + + // set vao 0 to some value + gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 4, 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, 1, gl.SHORT, false, 8, 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 8)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE, 4)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeNormalizedCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeNormalizedCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeNormalizedCase.prototype.test = function() { + var pointers = [ + // type test + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.FLOAT, 0, false, 0], + [1, gl.HALF_FLOAT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0], + [4, gl.INT_2_10_10_10_REV, 0, false, 0], + [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0], + [1, gl.BYTE, 0, true, 0], + [1, gl.SHORT, 0, true, 0], + [1, gl.INT, 0, true, 0], + [1, gl.FLOAT, 0, true, 0], + [1, gl.HALF_FLOAT, 0, true, 0], + [1, gl.UNSIGNED_BYTE, 0, true, 0], + [1, gl.UNSIGNED_SHORT, 0, true, 0], + [1, gl.UNSIGNED_INT, 0, true, 0], + [4, gl.INT_2_10_10_10_REV, 0, true, 0], + [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, true, 0] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, pointers[ndx][3])); + } + + var pointersI = [ + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0] + ]; + + for (var ndx = 0; ndx < pointersI.length; ++ndx) { + gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false)); + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false)); + + // set vao 0 to some value + gl.vertexAttribPointer(0, 1, gl.INT, true, 0, 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, 1, gl.INT, false, 0, 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, false)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, true)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeIntegerCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeIntegerCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeIntegerCase.prototype.test = function() { + var pointers = [ + // type test + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.FLOAT, 0, false, 0], + [1, gl.HALF_FLOAT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0], + [4, gl.INT_2_10_10_10_REV, 0, false, 0], + [4, gl.UNSIGNED_INT_2_10_10_10_REV, 0, false, 0] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false)); + } + + var pointersI = [ + [1, gl.BYTE, 0, false, 0], + [1, gl.SHORT, 0, false, 0], + [1, gl.INT, 0, false, 0], + [1, gl.UNSIGNED_BYTE, 0, false, 0], + [1, gl.UNSIGNED_SHORT, 0, false, 0], + [1, gl.UNSIGNED_INT, 0, false, 0] + ]; + + for (var ndx = 0; ndx < pointersI.length; ++ndx) { + gl.vertexAttribIPointer(0, pointersI[ndx][0], pointersI[ndx][1], pointersI[ndx][2], pointersI[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, true)); + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false)); + + // set vao 0 to some value + gl.vertexAttribIPointer(0, 1, gl.INT, 0, 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, false)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_INTEGER, true)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeEnabledCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeEnabledCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeEnabledCase.prototype.test = function() { + // Test with default VAO + + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false)); + gl.enableVertexAttribArray(0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, true)); + gl.disableVertexAttribArray(0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false)); + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + // set vao 0 to some value + gl.enableVertexAttribArray(0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.disableVertexAttribArray(0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, false)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_ENABLED, true)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeDivisorCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeDivisorCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeDivisorCase.prototype.test = function() { + // Test with default VAO + + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 0)); + gl.vertexAttribDivisor(0, 1); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 1)); + gl.vertexAttribDivisor(0, 5); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 5)); + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + // set vao 0 to some value + gl.vertexAttribDivisor(0, 1); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribDivisor(0, 5); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 5)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_DIVISOR, 1)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeBufferBindingCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeBufferBindingCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeBufferBindingCase.prototype.test = function() { + // Test with default VAO + + var buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + + gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0); + + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer)); + + gl.deleteBuffer(buffer); + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + var buffer0 = gl.createBuffer(); + var buffer1 = gl.createBuffer(); + + // initial + gl.bindVertexArray(vao0); + // set vao 0 to some value + gl.bindBuffer(gl.ARRAY_BUFFER, buffer0); + gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer1); + gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer1)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, buffer0)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buffer0); + gl.deleteBuffer(buffer1); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.VertexAttributeOffsetCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.VertexAttributeOffsetCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.VertexAttributeOffsetCase.prototype.test = function() { + var pointers = [ + [1, gl.BYTE, 0, false, 2 * 4], + [1, gl.SHORT, 0, false, 1 * 4], + [1, gl.INT, 0, false, 2 * 4], + [1, gl.FLOAT, 0, false, 0 * 4], + [1, gl.FLOAT, 0, false, 3 * 4], + [1, gl.FLOAT, 0, false, 2 * 4], + [1, gl.HALF_FLOAT, 0, false, 0 * 4], + [4, gl.HALF_FLOAT, 0, false, 1 * 4], + [4, gl.HALF_FLOAT, 0, false, 2 * 4] + ]; + + var buf = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buf); + + // Test with default VAO + + for (var ndx = 0; ndx < pointers.length; ++ndx) { + gl.vertexAttribPointer(0, pointers[ndx][0], pointers[ndx][1], pointers[ndx][3], pointers[ndx][2], pointers[ndx][4]); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, pointers[ndx][4])); + } + + // Test with multiple VAOs + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + // initial + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 0)); + + // set vao 0 to some value + gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 8); + + // set vao 1 to some other value + gl.bindVertexArray(vao1); + gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 4); + + // verify vao 1 state + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 4)); + + // verify vao 0 state + gl.bindVertexArray(vao0); + this.check(glsStateQuery.verifyVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_POINTER, 8)); + + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + gl.deleteBuffer(buf); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueFloatCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueFloatCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueFloatCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform highp float floatUniform;\n' + + 'uniform highp vec2 float2Uniform;\n' + + 'uniform highp vec3 float3Uniform;\n' + + 'uniform highp vec4 float4Uniform;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(floatUniform + float2Uniform.x + float3Uniform.x + float4Uniform.x);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + location = gl.getUniformLocation(program, 'floatUniform'); + gl.uniform1f(location, 1); + this.check(glsStateQuery.verifyUniform(program, location, 1)); + + location = gl.getUniformLocation(program, 'float2Uniform'); + gl.uniform2f(location, 1, 2); + this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2]))); + + location = gl.getUniformLocation(program, 'float3Uniform'); + gl.uniform3f(location, 1, 2, 3); + this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2, 3]))); + + location = gl.getUniformLocation(program, 'float4Uniform'); + gl.uniform4f(location, 1, 2, 3, 4); + this.check(glsStateQuery.verifyUniform(program, location, new Float32Array([1, 2, 3, 4]))); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueIntCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueIntCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueIntCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform highp int intUniform;\n' + + 'uniform highp ivec2 int2Uniform;\n' + + 'uniform highp ivec3 int3Uniform;\n' + + 'uniform highp ivec4 int4Uniform;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(float(intUniform + int2Uniform.x + int3Uniform.x + int4Uniform.x));\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + location = gl.getUniformLocation(program, 'intUniform'); + gl.uniform1i(location, 1); + this.check(glsStateQuery.verifyUniform(program, location, 1)); + + location = gl.getUniformLocation(program, 'int2Uniform'); + gl.uniform2i(location, 1, 2); + this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2]))); + + location = gl.getUniformLocation(program, 'int3Uniform'); + gl.uniform3i(location, 1, 2, 3); + this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2, 3]))); + + location = gl.getUniformLocation(program, 'int4Uniform'); + gl.uniform4i(location, 1, 2, 3, 4); + this.check(glsStateQuery.verifyUniform(program, location, new Int32Array([1, 2, 3, 4]))); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueUintCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueUintCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueUintCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform highp uint uintUniform;\n' + + 'uniform highp uvec2 uint2Uniform;\n' + + 'uniform highp uvec3 uint3Uniform;\n' + + 'uniform highp uvec4 uint4Uniform;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(float(uintUniform + uint2Uniform.x + uint3Uniform.x + uint4Uniform.x));\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + location = gl.getUniformLocation(program, 'uintUniform'); + gl.uniform1ui(location, 1); + this.check(glsStateQuery.verifyUniform(program, location, 1)); + + location = gl.getUniformLocation(program, 'uint2Uniform'); + gl.uniform2ui(location, 1, 2); + this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2]))); + + location = gl.getUniformLocation(program, 'uint3Uniform'); + gl.uniform3ui(location, 1, 2, 3); + this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2, 3]))); + + location = gl.getUniformLocation(program, 'uint4Uniform'); + gl.uniform4ui(location, 1, 2, 3, 4); + this.check(glsStateQuery.verifyUniform(program, location, new Uint32Array([1, 2, 3, 4]))); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueBooleanCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueBooleanCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueBooleanCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform bool boolUniform;\n' + + 'uniform bvec2 bool2Uniform;\n' + + 'uniform bvec3 bool3Uniform;\n' + + 'uniform bvec4 bool4Uniform;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(float(boolUniform) + float(bool2Uniform.x) + float(bool3Uniform.x) + float(bool4Uniform.x));\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + location = gl.getUniformLocation(program, 'boolUniform'); + gl.uniform1i(location, 1); + this.check(glsStateQuery.verifyUniform(program, location, true)); + + location = gl.getUniformLocation(program, 'bool2Uniform'); + gl.uniform2i(location, 1, 0); + this.check(glsStateQuery.verifyUniform(program, location, [true, false])); + + location = gl.getUniformLocation(program, 'bool3Uniform'); + gl.uniform3i(location, 1, 0, 1); + this.check(glsStateQuery.verifyUniform(program, location, [true, false, true])); + + location = gl.getUniformLocation(program, 'bool4Uniform'); + gl.uniform4i(location, 1, 0, 1, 0); + this.check(glsStateQuery.verifyUniform(program, location, [true, false, true, false])); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueSamplerCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueSamplerCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueSamplerCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'uniform highp sampler2D uniformSampler;\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(textureSize(uniformSampler, 0).x);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + location = gl.getUniformLocation(program, 'uniformSampler'); + gl.uniform1i(location, 1); + this.check(glsStateQuery.verifyUniform(program, location, 1)); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueArrayCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueArrayCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueArrayCase.prototype.test = function() { + var testVertSource = + '#version 300 es\n' + + 'uniform highp float arrayUniform[5];' + + 'uniform highp vec2 array2Uniform[5];' + + 'uniform highp vec3 array3Uniform[5];' + + 'uniform highp vec4 array4Uniform[5];' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = \n' + + ' + vec4(arrayUniform[0] + arrayUniform[1] + arrayUniform[2] + arrayUniform[3] + arrayUniform[4])\n' + + ' + vec4(array2Uniform[0].x + array2Uniform[1].x + array2Uniform[2].x + array2Uniform[3].x + array2Uniform[4].x)\n' + + ' + vec4(array3Uniform[0].x + array3Uniform[1].x + array3Uniform[2].x + array3Uniform[3].x + array3Uniform[4].x)\n' + + ' + vec4(array4Uniform[0].x + array4Uniform[1].x + array4Uniform[2].x + array4Uniform[3].x + array4Uniform[4].x);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + var uniformValue = [ + -1.0, 0.1, 4.0, 800.0, + 13.0, 55.0, 12.0, 91.0, + -55.1, 1.1, 98.0, 19.0, + 41.0, 65.0, 4.0, 12.2, + 95.0, 77.0, 32.0, 48.0 + ]; + + location = gl.getUniformLocation(program, 'arrayUniform'); + gl.uniform1fv(location, new Float32Array(uniformValue.slice(0, 5))); + + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[0]'), uniformValue[0])); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[1]'), uniformValue[1])); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[2]'), uniformValue[2])); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[3]'), uniformValue[3])); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'arrayUniform[4]'), uniformValue[4])); + + location = gl.getUniformLocation(program, 'array2Uniform'); + gl.uniform2fv(location, new Float32Array(uniformValue.slice(0, 10))); + + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[0]'), new Float32Array([uniformValue[2 * 0], uniformValue[(2 * 0) + 1]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[1]'), new Float32Array([uniformValue[2 * 1], uniformValue[(2 * 1) + 1]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[2]'), new Float32Array([uniformValue[2 * 2], uniformValue[(2 * 2) + 1]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[3]'), new Float32Array([uniformValue[2 * 3], uniformValue[(2 * 3) + 1]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array2Uniform[4]'), new Float32Array([uniformValue[2 * 4], uniformValue[(2 * 4) + 1]]))); + + location = gl.getUniformLocation(program, 'array3Uniform'); + gl.uniform3fv(location, new Float32Array(uniformValue.slice(0, 15))); + + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[0]'), new Float32Array([uniformValue[3 * 0], uniformValue[(3 * 0) + 1], uniformValue[(3 * 0) + 2]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[1]'), new Float32Array([uniformValue[3 * 1], uniformValue[(3 * 1) + 1], uniformValue[(3 * 1) + 2]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[2]'), new Float32Array([uniformValue[3 * 2], uniformValue[(3 * 2) + 1], uniformValue[(3 * 2) + 2]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[3]'), new Float32Array([uniformValue[3 * 3], uniformValue[(3 * 3) + 1], uniformValue[(3 * 3) + 2]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array3Uniform[4]'), new Float32Array([uniformValue[3 * 4], uniformValue[(3 * 4) + 1], uniformValue[(3 * 4) + 2]]))); + + location = gl.getUniformLocation(program, 'array4Uniform'); + gl.uniform4fv(location, new Float32Array(uniformValue)); + + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[0]'), new Float32Array([uniformValue[4 * 0], uniformValue[(4 * 0) + 1], uniformValue[(4 * 0) + 2], uniformValue[(4 * 0) + 3]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[1]'), new Float32Array([uniformValue[4 * 1], uniformValue[(4 * 1) + 1], uniformValue[(4 * 1) + 2], uniformValue[(4 * 1) + 3]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[2]'), new Float32Array([uniformValue[4 * 2], uniformValue[(4 * 2) + 1], uniformValue[(4 * 2) + 2], uniformValue[(4 * 2) + 3]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[3]'), new Float32Array([uniformValue[4 * 3], uniformValue[(4 * 3) + 1], uniformValue[(4 * 3) + 2], uniformValue[(4 * 3) + 3]]))); + this.check(glsStateQuery.verifyUniform(program, gl.getUniformLocation(program, 'array4Uniform[4]'), new Float32Array([uniformValue[4 * 4], uniformValue[(4 * 4) + 1], uniformValue[(4 * 4) + 2], uniformValue[(4 * 4) + 3]]))); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderStateQueryTests.UniformValueMatrixCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); +}; + +setParentClass(es3fShaderStateQueryTests.UniformValueMatrixCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.UniformValueMatrixCase.prototype.test = function() { + var transpose = function(rows, cols, data) { + var matrix = tcuMatrix.matrixFromDataArray(rows, cols, data); + var result = []; + for (var col = 0; col < cols; col++) + result.push(matrix.getColumn(col)); + return new Float32Array([].concat.apply([], result)); + }; + + var testVertSource = + '#version 300 es\n' + + 'uniform highp mat2 mat2Uniform;' + + 'uniform highp mat3 mat3Uniform;' + + 'uniform highp mat4 mat4Uniform;' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(mat2Uniform[0][0] + mat3Uniform[0][0] + mat4Uniform[0][0]);\n' + + '}\n'; + var testFragSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 fragColor;' + + 'void main (void)\n' + + '{\n' + + ' fragColor = vec4(0.0);\n' + + '}\n'; + + var shaderVert = gl.createShader(gl.VERTEX_SHADER); + var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER); + + gl.shaderSource(shaderVert, testVertSource); + gl.shaderSource(shaderFrag, testFragSource); + + gl.compileShader(shaderVert); + gl.compileShader(shaderFrag); + + var program = gl.createProgram(); + gl.attachShader(program, shaderVert); + gl.attachShader(program, shaderFrag); + gl.linkProgram(program); + gl.useProgram(program); + + var location; + + var matrixValues = [ + -1.0, 0.1, 4.0, 800.0, + 13.0, 55.0, 12.0, 91.0, + -55.1, 1.1, 98.0, 19.0, + 41.0, 65.0, 4.0, 12.0 + ]; + + // the values of the matrix are returned in column major order but they can be given in either order + + location = gl.getUniformLocation(program, 'mat2Uniform'); + var m2 = new Float32Array(matrixValues.slice(0, 2 * 2)); + gl.uniformMatrix2fv(location, false, m2); + this.check(glsStateQuery.verifyUniform(program, location, m2)); + gl.uniformMatrix2fv(location, true, m2); + this.check(glsStateQuery.verifyUniform(program, location, transpose(2, 2, m2))); + + location = gl.getUniformLocation(program, 'mat3Uniform'); + var m3 = new Float32Array(matrixValues.slice(0, 3 * 3)); + gl.uniformMatrix3fv(location, false, m3); + this.check(glsStateQuery.verifyUniform(program, location, m3)); + gl.uniformMatrix3fv(location, true, m3); + this.check(glsStateQuery.verifyUniform(program, location, transpose(3, 3, m3))); + + location = gl.getUniformLocation(program, 'mat4Uniform'); + var m4 = new Float32Array(matrixValues.slice(0, 4 * 4)); + gl.uniformMatrix4fv(location, false, m4); + this.check(glsStateQuery.verifyUniform(program, location, m4)); + gl.uniformMatrix4fv(location, true, m4); + this.check(glsStateQuery.verifyUniform(program, location, transpose(4, 4, m4))); + + gl.useProgram(null); + gl.deleteShader(shaderVert); + gl.deleteShader(shaderFrag); + gl.deleteProgram(program); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + * @param {number} shaderType + * @param {number} precisionType + */ +es3fShaderStateQueryTests.PrecisionFormatCase = function(name, description, shaderType, precisionType) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_shaderType = shaderType; + this.m_precisionType = precisionType; +}; + +setParentClass(es3fShaderStateQueryTests.PrecisionFormatCase, es3fApiCase.ApiCase); + +es3fShaderStateQueryTests.PrecisionFormatCase.prototype.test = function() { + var requirements = {}; + requirements[gl.LOW_FLOAT] = [0, 0, 8]; + requirements[gl.MEDIUM_FLOAT] = [13, 13, 10]; + requirements[gl.HIGH_FLOAT] = [127, 127, 23]; + requirements[gl.LOW_INT] = [8, 7, 0]; + requirements[gl.MEDIUM_INT] = [15, 14, 0]; + requirements[gl.HIGH_INT] = [31, 30, 0]; + + + var expected = requirements[this.m_precisionType]; + var result = gl.getShaderPrecisionFormat(this.m_shaderType, this.m_precisionType); + + bufferedLogToConsole('Precision:' + + ' range min = ' + result.rangeMin + + ' range max = ' + result.rangeMax + + ' precision = ' + result.precision); + + if (this.m_precisionType == gl.HIGH_FLOAT) { + // highp float must be IEEE 754 single + + this.check(result.rangeMin == expected[0] || + result.rangeMax == expected[1] || + result.precision == expected[2], + 'Invalid precision format, expected:' + + ' range min = ' + expected[0] + + ' range max = ' + expected[1] + + ' precision = ' + expected[2]); + } else{ + this.check(result.rangeMin >= expected[0] || + result.rangeMax >= expected[1] || + result.precision >= expected[2], + 'Invalid precision format, expected:' + + ' range min >= ' + expected[0] + + ' range max >= ' + expected[1] + + ' precision >= ' + expected[2]); + } +}; + +/** +* @constructor +* @extends {tcuTestCase.DeqpTest} +*/ +es3fShaderStateQueryTests.ShaderStateQueryTests = function() { + tcuTestCase.DeqpTest.call(this, 'shader', 'Shader State Query tests'); +}; + +es3fShaderStateQueryTests.ShaderStateQueryTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); +es3fShaderStateQueryTests.ShaderStateQueryTests.prototype.constructor = es3fShaderStateQueryTests.ShaderStateQueryTests; + +es3fShaderStateQueryTests.ShaderStateQueryTests.prototype.init = function() { + // shader + this.addChild(new es3fShaderStateQueryTests.ShaderTypeCase('shader_type', 'SHADER_TYPE')); + this.addChild(new es3fShaderStateQueryTests.ShaderCompileStatusCase('shader_compile_status', 'COMPILE_STATUS')); + this.addChild(new es3fShaderStateQueryTests.ShaderInfoLogCase('shader_info_log', 'INFO_LOG')); + this.addChild(new es3fShaderStateQueryTests.ShaderSourceCase('shader_source', 'SHADER_SOURCE')); + + // shader and program + this.addChild(new es3fShaderStateQueryTests.DeleteStatusCase('delete_status', 'DELETE_STATUS')); + + // // vertex-attrib + this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribInitialCase('current_vertex_attrib_initial', 'CURRENT_VERTEX_ATTRIB')); + this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribFloatCase('current_vertex_attrib_float', 'CURRENT_VERTEX_ATTRIB')); + this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribIntCase('current_vertex_attrib_int', 'CURRENT_VERTEX_ATTRIB')); + this.addChild(new es3fShaderStateQueryTests.CurrentVertexAttribUintCase('current_vertex_attrib_uint', 'CURRENT_VERTEX_ATTRIB')); + + // // program + this.addChild(new es3fShaderStateQueryTests.ProgramInfoLogCase('program_info_log', 'INFO_LOG')); + this.addChild(new es3fShaderStateQueryTests.ProgramValidateStatusCase('program_validate_status', 'VALIDATE_STATUS')); + this.addChild(new es3fShaderStateQueryTests.ProgramAttachedShadersCase('program_attached_shaders', 'ATTACHED_SHADERS')); + + this.addChild(new es3fShaderStateQueryTests.ProgramActiveUniformNameCase('program_active_uniform_name', 'ACTIVE_UNIFORMS')); + this.addChild(new es3fShaderStateQueryTests.ProgramUniformCase('program_active_uniform_types', 'UNIFORM_TYPE, UNIFORM_SIZE, and UNIFORM_IS_ROW_MAJOR')); + this.addChild(new es3fShaderStateQueryTests.ProgramActiveUniformBlocksCase ("program_active_uniform_blocks", "ACTIVE_UNIFORM_BLOCK_x")); + + // transform feedback + this.addChild(new es3fShaderStateQueryTests.TransformFeedbackCase('transform_feedback', 'TRANSFORM_FEEDBACK_BUFFER_MODE, TRANSFORM_FEEDBACK_VARYINGS, TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH')); + + // attribute related + this.addChild(new es3fShaderStateQueryTests.ActiveAttributesCase('active_attributes', 'ACTIVE_ATTRIBUTES and ACTIVE_ATTRIBUTE_MAX_LENGTH')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeSizeCase('vertex_attrib_size', 'VERTEX_ATTRIB_ARRAY_SIZE')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeTypeCase('vertex_attrib_type', 'VERTEX_ATTRIB_ARRAY_TYPE')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeStrideCase('vertex_attrib_stride', 'VERTEX_ATTRIB_ARRAY_STRIDE')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeNormalizedCase('vertex_attrib_normalized', 'VERTEX_ATTRIB_ARRAY_NORMALIZED')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeIntegerCase('vertex_attrib_integer', 'VERTEX_ATTRIB_ARRAY_INTEGER')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeEnabledCase('vertex_attrib_array_enabled', 'VERTEX_ATTRIB_ARRAY_ENABLED')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeDivisorCase('vertex_attrib_array_divisor', 'VERTEX_ATTRIB_ARRAY_DIVISOR')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeBufferBindingCase('vertex_attrib_array_buffer_binding', 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING')); + this.addChild(new es3fShaderStateQueryTests.VertexAttributeOffsetCase('vertex_attrib_offset', 'VERTEX_ATTRIB_ARRAY_POINTER')); + + // uniform values + this.addChild(new es3fShaderStateQueryTests.UniformValueFloatCase('uniform_value_float', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueIntCase('uniform_value_int', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueUintCase('uniform_value_uint', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueBooleanCase('uniform_value_boolean', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueSamplerCase('uniform_value_sampler', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueArrayCase('uniform_value_array', 'GetUniform*')); + this.addChild(new es3fShaderStateQueryTests.UniformValueMatrixCase('uniform_value_matrix', 'GetUniform*')); + + // precision format query + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_lowp_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.LOW_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_mediump_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.MEDIUM_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_highp_float', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.HIGH_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_lowp_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.LOW_INT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_mediump_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.MEDIUM_INT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_vertex_highp_int', 'GetShaderPrecisionFormat', gl.VERTEX_SHADER, gl.HIGH_INT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_lowp_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.LOW_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_mediump_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_highp_float', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.HIGH_FLOAT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_lowp_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.LOW_INT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_mediump_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.MEDIUM_INT)); + this.addChild(new es3fShaderStateQueryTests.PrecisionFormatCase('precision_fragment_highp_int', 'GetShaderPrecisionFormat', gl.FRAGMENT_SHADER, gl.HIGH_INT)); +}; + +/** +* Run test +* @param {WebGL2RenderingContext} context +*/ +es3fShaderStateQueryTests.run = function(context) { + gl = context; + //Set up Test Root parameters + var state = tcuTestCase.runner; + state.setRoot(new es3fShaderStateQueryTests.ShaderStateQueryTests()); + + //Set up name and description of this test series. + setCurrentTestName(state.testCases.fullName()); + description(state.testCases.getDescription()); + + try { + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to es3fShaderStateQueryTests.run tests', false); + tcuTestCase.runner.terminate(); + } +}; + +}); |