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

});