diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderApiTests.js | 650 |
1 files changed, 650 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderApiTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderApiTests.js new file mode 100644 index 0000000000..2768f0325b --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderApiTests.js @@ -0,0 +1,650 @@ +/*------------------------------------------------------------------------- + * 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.es3fShaderApiTests'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.delibs.debase.deString'); +goog.require('framework.opengl.gluShaderProgram'); +goog.require('functional.gles3.es3fApiCase'); + +goog.scope(function() { +var es3fShaderApiTests = functional.gles3.es3fShaderApiTests; +var tcuTestCase = framework.common.tcuTestCase; +var es3fApiCase = functional.gles3.es3fApiCase; +var gluShaderProgram = framework.opengl.gluShaderProgram; +var deRandom = framework.delibs.debase.deRandom; +var deString = framework.delibs.debase.deString; + +/** @type {WebGL2RenderingContext} */ var gl; + +var setParentClass = function(child, parent) { + child.prototype = Object.create(parent.prototype); + child.prototype.constructor = child; +}; + +var getSimpleShaderSource = function(shaderType) { + var simpleVertexShaderSource = + '#version 300 es\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = vec4(0.0);\n' + + '}\n'; + + var simpleFragmentShaderSource = + '#version 300 es\n' + + 'layout(location = 0) out mediump vec4 o_fragColor;\n' + + 'void main (void)\n' + + '{\n' + + ' o_fragColor = vec4(0.0);\n' + + '}\n'; + + switch (shaderType) { + case gluShaderProgram.shaderType.VERTEX: + return simpleVertexShaderSource; + case gluShaderProgram.shaderType.FRAGMENT: + return simpleFragmentShaderSource; + default: + throw new Error('Invalid shader type'); + } +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.CreateShaderCase = function(name, description, shaderType) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_shaderType = shaderType; +}; + +setParentClass(es3fShaderApiTests.CreateShaderCase, es3fApiCase.ApiCase); + +es3fShaderApiTests.CreateShaderCase.prototype.test = function() { + var shaderObject = gl.createShader(gluShaderProgram.getGLShaderType(gl, this.m_shaderType)); + this.check(shaderObject != null); + gl.deleteShader(shaderObject); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.CompileShaderCase = function(name, description, shaderType) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_shaderType = shaderType; +}; + +setParentClass(es3fShaderApiTests.CompileShaderCase, es3fApiCase.ApiCase); + +es3fShaderApiTests.CompileShaderCase.prototype.checkCompileStatus = function(shader) { + var status = /** @type {boolean} */ (gl.getShaderParameter(shader, gl.COMPILE_STATUS)); + return status; +}; + +es3fShaderApiTests.CompileShaderCase.prototype.test = function() { + var shaderObject = gl.createShader(gluShaderProgram.getGLShaderType(gl, this.m_shaderType)); + var shaderSource = getSimpleShaderSource(this.m_shaderType); + + this.check(shaderObject != null); + + gl.shaderSource(shaderObject, shaderSource); + gl.compileShader(shaderObject); + + this.check(this.checkCompileStatus(shaderObject)); + + gl.deleteShader(shaderObject); +}; + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ShaderSourceReplaceCase = function(name, description, shaderType) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_shaderType = shaderType; +}; + +setParentClass(es3fShaderApiTests.ShaderSourceReplaceCase, es3fApiCase.ApiCase); + +es3fShaderApiTests.ShaderSourceReplaceCase.prototype.generateFirstSource = function() { + return getSimpleShaderSource(this.m_shaderType); +}; + +es3fShaderApiTests.ShaderSourceReplaceCase.prototype.generateSecondSource = function() { + var source = '#version 300 es\n' + + 'precision mediump float;\n'; + + if (this.m_shaderType == gluShaderProgram.shaderType.FRAGMENT) + source += 'layout(location = 0) out mediump vec4 o_fragColor;\n'; + + source += 'void main()\n'+ + '{\n'+ + ' float variable = 1.0f;\n'; + + if (this.m_shaderType == gluShaderProgram.shaderType.VERTEX) source += ' gl_Position = vec4(variable);\n'; + else if (this.m_shaderType == gluShaderProgram.shaderType.FRAGMENT) source += ' o_fragColor = vec4(variable);\n'; + + source += '}\n'; + + return source; +}; + +es3fShaderApiTests.ShaderSourceReplaceCase.prototype.test = function() { + var shaderObject = gl.createShader(gluShaderProgram.getGLShaderType(gl, this.m_shaderType)); + var firstSource = this.generateFirstSource(); + var secondSource = this.generateSecondSource(); + + this.check(shaderObject != null); + + gl.shaderSource(shaderObject, firstSource); + this.check(firstSource == gl.getShaderSource(shaderObject)); + + gl.shaderSource(shaderObject, secondSource); + this.check(secondSource == gl.getShaderSource(shaderObject)); + + gl.deleteShader(shaderObject); +}; + +/** + * @constructor + */ +es3fShaderApiTests.SourceGenerator = function() {}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + * @return {string} + */ +es3fShaderApiTests.SourceGenerator.prototype.next = function(shaderType) { + throw new Error('Virtual function. Please override'); +}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + * @return {boolean} + */ +es3fShaderApiTests.SourceGenerator.prototype.finished = function(shaderType) { + throw new Error('Virtual function. Please override'); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.SourceGenerator} + */ +es3fShaderApiTests.ConstantShaderGenerator = function(rnd) { + es3fShaderApiTests.SourceGenerator.call(this); + this.m_rnd = rnd; +}; + +setParentClass(es3fShaderApiTests.ConstantShaderGenerator, es3fShaderApiTests.SourceGenerator); + +es3fShaderApiTests.SourceGenerator.prototype.next = function(shaderType) { + var value = this.m_rnd.getFloat(0.0, 1.0); + var outputName = (shaderType == gluShaderProgram.shaderType.VERTEX) ? 'gl_Position' : 'o_fragColor'; + + var out = '#version 300 es\n'; + + if (shaderType == gluShaderProgram.shaderType.FRAGMENT) + out += 'layout(location = 0) out mediump vec4 o_fragColor;\n'; + + out += 'void main (void)\n'; + out += '{\n'; + out += ' ' + outputName + ' = vec4(' + value + ');\n'; + out += '}\n'; + + return out; +}; + +es3fShaderApiTests.SourceGenerator.prototype.finished = function(shaderType) { + return false; +}; + +// Shader allocation utility + +/** + * @constructor + * @param {es3fShaderApiTests.SourceGenerator} generator + */ +es3fShaderApiTests.ShaderAllocator = function(generator) { + this.m_srcGen = generator; + this.m_shaders = {}; +}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ShaderAllocator.prototype.createShader = function(shaderType) { + var shader = new gluShaderProgram.Shader(gl, shaderType); + this.m_shaders[shaderType] = shader; + this.setSource(shaderType); + return shader; +}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ShaderAllocator.prototype.deleteShader = function(shaderType) { + this.m_shaders[shaderType].destroy(); + this.m_shaders[shaderType] = null; +}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ShaderAllocator.prototype.setSource = function(shaderType) { + var source = this.m_srcGen.next(shaderType); + this.m_shaders[shaderType].setSources(source); +}; + +/** + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ShaderAllocator.prototype.get = function(shaderType) { + return this.m_shaders[shaderType]; +}; + +// Base class for simple program API tests + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + */ +es3fShaderApiTests.SimpleProgramCase = function(name, description) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_vertShader = null; + this.m_fragShader = null; + this.m_program = null; +}; + +setParentClass(es3fShaderApiTests.SimpleProgramCase, es3fApiCase.ApiCase); + +es3fShaderApiTests.SimpleProgramCase.prototype.compileShaders = function() { + var vertSource = getSimpleShaderSource(gluShaderProgram.shaderType.VERTEX); + var fragSource = getSimpleShaderSource(gluShaderProgram.shaderType.FRAGMENT); + + var vertShader = gl.createShader(gl.VERTEX_SHADER); + var fragShader = gl.createShader(gl.FRAGMENT_SHADER); + + this.check(vertShader != null); + this.check(fragShader != null); + + gl.shaderSource(vertShader, vertSource); + gl.compileShader(vertShader); + + gl.shaderSource(fragShader, fragSource); + gl.compileShader(fragShader); + + this.m_vertShader = vertShader; + this.m_fragShader = fragShader; +}; + +es3fShaderApiTests.SimpleProgramCase.prototype.linkProgram = function() { + var program = gl.createProgram(); + + this.check(program != null); + + gl.attachShader(program, this.m_vertShader); + gl.attachShader(program, this.m_fragShader); + + gl.linkProgram(program); + + this.m_program = program; +}; + +es3fShaderApiTests.SimpleProgramCase.prototype.cleanup = function() { + gl.deleteShader(this.m_vertShader); + gl.deleteShader(this.m_fragShader); + gl.deleteProgram(this.m_program); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.SimpleProgramCase} + * @param {string} name + * @param {string} description + */ +es3fShaderApiTests.DeleteShaderCase = function(name, description) { + es3fShaderApiTests.SimpleProgramCase.call(this, name, description); +}; + +setParentClass(es3fShaderApiTests.DeleteShaderCase, es3fShaderApiTests.SimpleProgramCase); + +es3fShaderApiTests.DeleteShaderCase.prototype.checkDeleteStatus = function(shader) { + var status = /** @type {boolean} */ (gl.getShaderParameter(shader, gl.DELETE_STATUS)); + return status; +}; + +es3fShaderApiTests.DeleteShaderCase.prototype.deleteShaders = function() { + gl.deleteShader(this.m_vertShader); + gl.deleteShader(this.m_fragShader); +}; + +es3fShaderApiTests.DeleteShaderCase.prototype.test = function() { + this.compileShaders(); + this.linkProgram(); + + this.deleteShaders(); + + this.check(this.checkDeleteStatus(this.m_vertShader) && this.checkDeleteStatus(this.m_fragShader)); + + gl.deleteProgram(this.m_program); + + this.check(!(gl.isShader(this.m_vertShader) || gl.isShader(this.m_fragShader))); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.SimpleProgramCase} + * @param {string} name + * @param {string} description + */ +es3fShaderApiTests.LinkVertexFragmentCase = function(name, description) { + es3fShaderApiTests.SimpleProgramCase.call(this, name, description); +}; + +setParentClass(es3fShaderApiTests.LinkVertexFragmentCase, es3fShaderApiTests.SimpleProgramCase); + +es3fShaderApiTests.LinkVertexFragmentCase.prototype.checkLinkStatus = function(program) { + var status = /** @type {boolean} */ (gl.getProgramParameter(program, gl.LINK_STATUS)); + return status; +}; + +es3fShaderApiTests.LinkVertexFragmentCase.prototype.test = function() { + this.compileShaders(); + this.linkProgram(); + + this.check(this.checkLinkStatus(this.m_program), 'Fail, expected LINK_STATUS to be TRUE.'); + + this.cleanup(); +}; + +// Base class for program state persistence cases + +/** + * @constructor + * @extends {es3fApiCase.ApiCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateCase = function(name, description, shaderType) { + es3fApiCase.ApiCase.call(this, name, description, gl); + this.m_shaderType = shaderType; + this.m_rnd = new deRandom.Random(deString.deStringHash(name) ^ 0x713de0ca); +}; + +setParentClass(es3fShaderApiTests.ProgramStateCase, es3fApiCase.ApiCase); + +/** + * @param {gluShaderProgram.Program} program + * @param {es3fShaderApiTests.ShaderAllocator} shaders + */ +es3fShaderApiTests.ProgramStateCase.prototype.buildProgram = function(program, shaders) { + var vertShader = shaders.createShader(gluShaderProgram.shaderType.VERTEX); + var fragShader = shaders.createShader(gluShaderProgram.shaderType.FRAGMENT); + + vertShader.compile(); + fragShader.compile(); + + program.attachShader(vertShader.getShader()); + program.attachShader(fragShader.getShader()); + program.link(); +}; + +/** + * @param {gluShaderProgram.Program} program + * @param {gluShaderProgram.ProgramInfo} reference + */ +es3fShaderApiTests.ProgramStateCase.prototype.verify = function(program, reference) { + var programInfo = program.getInfo(); + this.check(programInfo.linkOk, 'Fail, link status may only change as a result of linking'); + + this.check(programInfo.linkTimeUs == reference.linkTimeUs, 'Fail, reported link time changed.'); + + this.check(programInfo.infoLog == reference.infoLog, 'Fail, program infolog changed.'); +}; + +es3fShaderApiTests.ProgramStateCase.prototype.test = function() { + var sourceGen = new es3fShaderApiTests.ConstantShaderGenerator(this.m_rnd); + + var shaders = new es3fShaderApiTests.ShaderAllocator(sourceGen); + var program = new gluShaderProgram.Program(gl); + + this.buildProgram(program, shaders); + + if (program.getLinkStatus()) { + var programInfo = program.getInfo(); + + this.executeForProgram(program, shaders); + + this.verify(program, programInfo); + + } else{ + this.check(false, "Fail, couldn't link program."); + } + +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateDetachShaderCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateDetachShaderCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateDetachShaderCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + program.detachShader(caseShader.getShader()); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateReattachShaderCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateReattachShaderCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateReattachShaderCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + program.detachShader(caseShader.getShader()); + program.attachShader(caseShader.getShader()); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateDeleteShaderCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateDeleteShaderCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateDeleteShaderCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + program.detachShader(caseShader.getShader()); + shaders.deleteShader(this.m_shaderType); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateReplaceShaderCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateReplaceShaderCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateReplaceShaderCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + program.detachShader(caseShader.getShader()); + shaders.deleteShader(this.m_shaderType); + program.attachShader(shaders.createShader(this.m_shaderType).getShader()); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateRecompileShaderCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateRecompileShaderCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateRecompileShaderCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + caseShader.compile(); +}; + +/** + * @constructor + * @extends {es3fShaderApiTests.ProgramStateCase} + * @param {string} name + * @param {string} description + * @param {gluShaderProgram.shaderType} shaderType + */ +es3fShaderApiTests.ProgramStateReplaceSourceCase = function(name, description, shaderType) { + es3fShaderApiTests.ProgramStateCase.call(this, name, description, shaderType); +}; + +setParentClass(es3fShaderApiTests.ProgramStateReplaceSourceCase, es3fShaderApiTests.ProgramStateCase); + +es3fShaderApiTests.ProgramStateReplaceSourceCase.prototype.executeForProgram = function(program, shaders) { + var caseShader = shaders.get(this.m_shaderType); + shaders.setSource(this.m_shaderType); + caseShader.compile(); +}; + +/** +* @constructor +* @extends {tcuTestCase.DeqpTest} +*/ +es3fShaderApiTests.ShaderApiTests = function() { + tcuTestCase.DeqpTest.call(this, 'shader_api', 'Shader API Cases'); +}; + +es3fShaderApiTests.ShaderApiTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); +es3fShaderApiTests.ShaderApiTests.prototype.constructor = es3fShaderApiTests.ShaderApiTests; + +es3fShaderApiTests.ShaderApiTests.prototype.init = function() { + // create and delete shaders + var createDeleteGroup = new tcuTestCase.DeqpTest('create_delete', 'glCreateShader() tests'); + this.addChild(createDeleteGroup); + + createDeleteGroup.addChild(new es3fShaderApiTests.CreateShaderCase('create_vertex_shader', 'Create vertex shader object', gluShaderProgram.shaderType.VERTEX)); + createDeleteGroup.addChild(new es3fShaderApiTests.CreateShaderCase('create_fragment_shader', 'Create fragment shader object', gluShaderProgram.shaderType.FRAGMENT)); + + createDeleteGroup.addChild(new es3fShaderApiTests.DeleteShaderCase('delete_vertex_fragment', 'Delete vertex shader and fragment shader')); + + // compile and link + var compileLinkGroup = new tcuTestCase.DeqpTest('compile_link', 'Compile and link tests'); + this.addChild(compileLinkGroup); + + compileLinkGroup.addChild(new es3fShaderApiTests.CompileShaderCase('compile_vertex_shader', 'Compile vertex shader', gluShaderProgram.shaderType.VERTEX)); + compileLinkGroup.addChild(new es3fShaderApiTests.CompileShaderCase('compile_fragment_shader', 'Compile fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + + compileLinkGroup.addChild(new es3fShaderApiTests.LinkVertexFragmentCase('link_vertex_fragment', 'Link vertex and fragment shaders')); + + // shader source + var shaderSourceGroup = new tcuTestCase.DeqpTest('shader_source', 'glShaderSource() tests'); + this.addChild(shaderSourceGroup); + shaderSourceGroup.addChild(new es3fShaderApiTests.ShaderSourceReplaceCase('replace_source_vertex', 'Replace source code of vertex shader', gluShaderProgram.shaderType.VERTEX)); + shaderSourceGroup.addChild(new es3fShaderApiTests.ShaderSourceReplaceCase('replace_source_fragment', 'Replace source code of fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + + // link status and infolog + var linkStatusGroup = new tcuTestCase.DeqpTest('program_state', 'Program state persistence tests'); + this.addChild(linkStatusGroup); + + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateDetachShaderCase('detach_shader_vertex', 'detach vertex shader', gluShaderProgram.shaderType.VERTEX)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReattachShaderCase('reattach_shader_vertex', 'reattach vertex shader', gluShaderProgram.shaderType.VERTEX)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateDeleteShaderCase('delete_shader_vertex', 'delete vertex shader', gluShaderProgram.shaderType.VERTEX)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReplaceShaderCase('replace_shader_vertex', 'replace vertex shader object', gluShaderProgram.shaderType.VERTEX)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateRecompileShaderCase('recompile_shader_vertex', 'recompile vertex shader', gluShaderProgram.shaderType.VERTEX)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReplaceSourceCase('replace_source_vertex', 'replace vertex shader source', gluShaderProgram.shaderType.VERTEX)); + + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateDetachShaderCase('detach_shader_fragment', 'detach fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReattachShaderCase('reattach_shader_fragment', 'reattach fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateDeleteShaderCase('delete_shader_fragment', 'delete fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReplaceShaderCase('replace_shader_fragment', 'replace fragment shader object', gluShaderProgram.shaderType.FRAGMENT)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateRecompileShaderCase('recompile_shader_fragment', 'recompile fragment shader', gluShaderProgram.shaderType.FRAGMENT)); + linkStatusGroup.addChild(new es3fShaderApiTests.ProgramStateReplaceSourceCase('replace_source_fragment', 'replace fragment shader source', gluShaderProgram.shaderType.FRAGMENT)); + +}; + +/** +* Run test +* @param {WebGL2RenderingContext} context +*/ +es3fShaderApiTests.run = function(context) { + gl = context; + //Set up Test Root parameters + var state = tcuTestCase.runner; + state.setRoot(new es3fShaderApiTests.ShaderApiTests()); + + //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 es3fShaderApiTests.run tests', false); + tcuTestCase.runner.terminate(); + } +}; + +}); |