/*-------------------------------------------------------------------------
 * 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.es3fVertexArrayObjectTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.delibs.debase.deUtil');
goog.require('framework.opengl.gluShaderProgram');

goog.scope(function() {
var es3fVertexArrayObjectTests = functional.gles3.es3fVertexArrayObjectTests;
var tcuTestCase = framework.common.tcuTestCase;
var deRandom = framework.delibs.debase.deRandom;
var deString = framework.delibs.debase.deString;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var tcuSurface = framework.common.tcuSurface;
var tcuImageCompare = framework.common.tcuImageCompare;
var deUtil = framework.delibs.debase.deUtil;

/**
 * @constructor
 */
es3fVertexArrayObjectTests.Attribute = function() {
    this.enabled = false;
    this.size = 1;
    this.stride = 0;
    this.type = gl.FLOAT;
    this.integer = false;
    this.divisor = 0;
    this.offset = 0;
    this.normalized = false;
    this.bufferNdx = 0;
};

/**
 * @constructor
 * @struct
 */
es3fVertexArrayObjectTests.VertexArrayState = function() {
    this.attributes = [];
    this.elementArrayBuffer = 0;
};

/**
 * @constructor
 * @struct
 */
es3fVertexArrayObjectTests.BufferSpec = function(count, size, componentCount, stride, offset, type, intRangeMin, intRangeMax, floatRangeMin, floatRangeMax) {
    this.count = count;
    this.size = size;
    this.componentCount = componentCount;
    this.stride = stride;
    this.offset = offset;

    this.type = type;

    this.intRangeMin = intRangeMin;
    this.intRangeMax = intRangeMax;

    this.floatRangeMin = floatRangeMin;
    this.floatRangeMax = floatRangeMax;
};

/**
 * @constructor
 */
es3fVertexArrayObjectTests.Spec = function() {
    this.count = -1;
    this.instances = -1;
    this.useDrawElements = false;
    this.indexType = gl.NONE;
    this.indexOffset = -1;
    this.indexRangeMin = -1;
    this.indexRangeMax = -1;
    this.indexCount = -1;
    this.buffers = [];
};

/**
 * @constructor
 * @extends {tcuTestCase.DeqpTest}
 * @param {es3fVertexArrayObjectTests.Spec} spec
 * @param {string} name
 * @param {string} description
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest = function(spec, name, description) {
    tcuTestCase.DeqpTest.call(this, name, description);
    this.m_spec = spec;
    this.m_random = new deRandom.Random(deString.deStringHash(name));
    /** @type Array<WebGLBuffer>} */ this.m_buffers = [];
    // mapping 0 -> null object
    this.m_buffers.push(null);
};

es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.constructor = es3fVertexArrayObjectTests.VertexArrayObjectTest;

es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.init = function() {
    this.m_vaoProgram = this.createProgram(this.m_spec.vao);
    // m_log << tcu::TestLog::Message << "Program used with Vertex Array Object" << tcu::TestLog::EndMessage;
    // m_log << *m_vaoProgram;
    this.m_stateProgram = this.createProgram(this.m_spec.state);
    // m_log << tcu::TestLog::Message << "Program used with Vertex Array State" << tcu::TestLog::EndMessage;
    // m_log << *m_stateProgram;

    if (!this.m_vaoProgram.isOk() || !this.m_stateProgram.isOk())
        testFailedOptions('Failed to compile shaders', true);
};

/**
 * @param {number} target GL target
 * @param {number} index Index of the buffer to bind
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.bindBuffer = function(target, index) {
    if (typeof this.m_buffers[index] === 'undefined') {
        var data = this.createRandomBufferData(this.m_spec.buffers[index - 1]);
        var buffer = gl.createBuffer();
        this.m_buffers[index] = buffer;

        gl.bindBuffer(target, buffer);
        gl.bufferData(target, data, gl.DYNAMIC_DRAW);
        gl.bindBuffer(target, null);
    }

    gl.bindBuffer(target, this.m_buffers[index]);
};

/**
 * @param {es3fVertexArrayObjectTests.BufferSpec} buffer
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.createRandomBufferData = function(buffer) {
    var typedArray;
    switch (buffer.type) {
        case gl.FLOAT: typedArray = Float32Array; break;
        case gl.INT: typedArray = Int32Array; break;
        case gl.UNSIGNED_INT: typedArray = Uint32Array; break;
        case gl.SHORT: typedArray = Int16Array; break;
        case gl.UNSIGNED_SHORT: typedArray = Uint16Array; break;
        case gl.BYTE: typedArray = Int8Array; break;
        case gl.UNSIGNED_BYTE: typedArray = Uint8Array; break;
        default:
            throw new Error('Invalid type: ' + buffer.type);
    }

    var raw = new ArrayBuffer(buffer.size);
    var stride;

    if (buffer.stride != 0) {
        stride = buffer.stride;
    } else {
        switch (buffer.type) {
            case gl.FLOAT: stride = buffer.componentCount * 4; break;
            case gl.INT: stride = buffer.componentCount * 4; break;
            case gl.UNSIGNED_INT: stride = buffer.componentCount * 4; break;
            case gl.SHORT: stride = buffer.componentCount * 2; break;
            case gl.UNSIGNED_SHORT: stride = buffer.componentCount * 2; break;
            case gl.BYTE: stride = buffer.componentCount * 1; break;
            case gl.UNSIGNED_BYTE: stride = buffer.componentCount * 1; break;
        }
    }

    var offset = 0;

    for (var pos = 0; pos < buffer.count; pos++) {
        var data = new typedArray(raw, offset, buffer.componentCount);
        for (var componentNdx = 0; componentNdx < buffer.componentCount; componentNdx++) {
            switch (buffer.type) {
                case gl.FLOAT: {
                    data[componentNdx] = this.m_random.getFloat(buffer.floatRangeMin, buffer.floatRangeMax);
                    break;
                }
                default: {
                    data[componentNdx] = this.m_random.getInt(buffer.intRangeMin, buffer.intRangeMax);
                }
            }
        }

        offset += stride;
    }

    return new typedArray(raw);
};

/**
 * @param {es3fVertexArrayObjectTests.VertexArrayState} state
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.createProgram = function(state) {
    var vtx = '';
    var value = '';

    vtx += '#version 300 es\n';

    for (var attribNdx = 0; attribNdx < state.attributes.length; attribNdx++) {
        if (state.attributes[attribNdx].integer)
            vtx += 'layout(location = ' + attribNdx + ') in mediump ivec4 a_attrib' + attribNdx + ';\n';
        else
            vtx += 'layout(location = ' + attribNdx + ') in mediump vec4 a_attrib' + attribNdx + ';\n';

        if (state.attributes[attribNdx].integer) {
            var scale = 0.0;

            // TODO: Should it be state.attributes[attribNdx].type?
            switch (state.attributes[attribNdx].type) {
                case gl.SHORT: scale = (1.0 / ((1 << 14) - 1)); break;
                case gl.UNSIGNED_SHORT: scale = (1.0 / ((1 << 15) - 1)); break;
                case gl.INT: scale = (1.0 / ((1 << 30) - 1)); break;
                case gl.UNSIGNED_INT: scale = (1.0 / ((1 << 31) - 1)); break;
                case gl.BYTE: scale = (1.0 / ((1 << 6) - 1)); break;
                case gl.UNSIGNED_BYTE: scale = (1.0 / ((1 << 7) - 1)); break;

                default:
                    throw new Error('Invalid type: ' + state.attributes[0].type);
            }
            value += (attribNdx != 0 ? ' + ' : '') + scale + ' * vec4(a_attrib' + attribNdx + ')';
        } else if (state.attributes[attribNdx].type != gl.FLOAT && !state.attributes[attribNdx].normalized) {
            var scale = 0.0;

            switch (state.attributes[attribNdx].type) {
                case gl.SHORT: scale = (0.5 / ((1 << 14) - 1)); break;
                case gl.UNSIGNED_SHORT: scale = (0.5 / ((1 << 15) - 1)); break;
                case gl.INT: scale = (0.5 / ((1 << 30) - 1)); break;
                case gl.UNSIGNED_INT: scale = (0.5 / ((1 << 31) - 1)); break;
                case gl.BYTE: scale = (0.5 / ((1 << 6) - 1)); break;
                case gl.UNSIGNED_BYTE: scale = (0.5 / ((1 << 7) - 1)); break;

                default:
                    throw new Error('Invalid type: ' + state.attributes[0].type);
            }
            value += (attribNdx != 0 ? ' + ' : '') + scale + ' * a_attrib' + attribNdx;
        } else
            value += (attribNdx != 0 ? ' + ' : '') + 'a_attrib' + attribNdx;
    }

    vtx +=
        'out mediump vec4 v_value;\n' +
        'void main (void)\n' +
        '{\n' +
        '\tv_value = ' + value + ';\n';

    if (state.attributes[0].integer) {
        var scale = 0.0;

        switch (state.attributes[0].type) {
            case gl.SHORT: scale = (1.0 / ((1 << 14) - 1)); break;
            case gl.UNSIGNED_SHORT: scale = (1.0 / ((1 << 15) - 1)); break;
            case gl.INT: scale = (1.0 / ((1 << 30) - 1)); break;
            case gl.UNSIGNED_INT: scale = (1.0 / ((1 << 31) - 1)); break;
            case gl.BYTE: scale = (1.0 / ((1 << 6) - 1)); break;
            case gl.UNSIGNED_BYTE: scale = (1.0 / ((1 << 7) - 1)); break;

            default:
                throw new Error('Invalid type: ' + state.attributes[0].type);
        }

        vtx +=
            '\tgl_Position = vec4(' + scale + ' * ' + 'vec3(a_attrib0.xyz), 1.0);\n' +
            '}';
    } else {
        if (state.attributes[0].normalized || state.attributes[0].type == gl.FLOAT) {
            vtx +=
                '\tgl_Position = vec4(a_attrib0.xyz, 1.0);\n' +
                '}';
        } else {
            var scale = 0.0;

            switch (state.attributes[0].type) {
                case gl.SHORT: scale = (1.0 / ((1 << 14) - 1)); break;
                case gl.UNSIGNED_SHORT: scale = (1.0 / ((1 << 15) - 1)); break;
                case gl.INT: scale = (1.0 / ((1 << 30) - 1)); break;
                case gl.UNSIGNED_INT: scale = (1.0 / ((1 << 31) - 1)); break;
                case gl.BYTE: scale = (1.0 / ((1 << 6) - 1)); break;
                case gl.UNSIGNED_BYTE: scale = (1.0 / ((1 << 7) - 1)); break;

                default:
                    throw new Error('Invalid type: ' + state.attributes[0].type);
            }

            scale *= 0.5;

            vtx +=
                '\tgl_Position = vec4(' + scale + ' * ' + 'a_attrib0.xyz, 1.0);\n' +
                '}';
        }
    }

    var fragmentShader =
        '#version 300 es\n' +
        'in mediump vec4 v_value;\n' +
        'layout(location = 0) out mediump vec4 fragColor;\n' +
        'void main (void)\n' +
        '{\n' +
        '\tfragColor = vec4(v_value.xyz, 1.0);\n' +
        '}';

    return new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtx, fragmentShader));
};

/**
 * @param {es3fVertexArrayObjectTests.VertexArrayState} state
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.setState = function(state) {
    this.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, state.elementArrayBuffer);

    for (var attribNdx = 0; attribNdx < state.attributes.length; attribNdx++) {
        this.bindBuffer(gl.ARRAY_BUFFER, state.attributes[attribNdx].bufferNdx);
        if (state.attributes[attribNdx].enabled)
            gl.enableVertexAttribArray(attribNdx);
        else
            gl.disableVertexAttribArray(attribNdx);

        if (state.attributes[attribNdx].integer)
            gl.vertexAttribIPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].stride, state.attributes[attribNdx].offset);
        else
            gl.vertexAttribPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].normalized, state.attributes[attribNdx].stride, state.attributes[attribNdx].offset);

        gl.vertexAttribDivisor(attribNdx, state.attributes[attribNdx].divisor);
    }
};

/**
 * @param {es3fVertexArrayObjectTests.VertexArrayState} state
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.makeDrawCall = function(state) {
    gl.clearColor(0.7, 0.7, 0.7, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT);
    var spec = this.m_spec;

    if (spec.useDrawElements) {
        if (spec.instances == 0)
            gl.drawElements(gl.TRIANGLES, spec.count, spec.indexType, spec.indexOffset);
        else
            gl.drawElementsInstanced(gl.TRIANGLES, spec.count, spec.indexType, spec.indexOffset, spec.instances);
    } else {
        if (spec.instances == 0)
            gl.drawArrays(gl.TRIANGLES, 0, spec.count);
        else
            gl.drawArraysInstanced(gl.TRIANGLES, 0, spec.count, spec.instances);
    }
};

/**
 * @param {tcuSurface.Surface} vaoResult
 * @param {tcuSurface.Surface} defaultResult
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.render = function(vaoResult, defaultResult) {
   var vao = gl.createVertexArray();

    gl.bindVertexArray(vao);
    this.setState(this.m_spec.vao);
    gl.bindVertexArray(null);

    this.setState(this.m_spec.state);

    gl.bindVertexArray(vao);
    gl.useProgram(this.m_vaoProgram.getProgram());
    this.makeDrawCall(this.m_spec.vao);
    vaoResult.readViewport();
    this.setState(this.m_spec.vao);
    gl.bindVertexArray(null);

    gl.useProgram(this.m_stateProgram.getProgram());
    this.makeDrawCall(this.m_spec.state);
    defaultResult.readViewport();

    gl.deleteVertexArray(vao);
};

/**
 * @param {tcuSurface.Surface} vaoRef
 * @param {tcuSurface.Surface} defaultRef
 */
es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.genReferences = function(vaoRef, defaultRef) {
    this.setState(this.m_spec.vao);
    gl.useProgram(this.m_vaoProgram.getProgram());
    this.makeDrawCall(this.m_spec.vao);
    vaoRef.readViewport();

    this.setState(this.m_spec.state);
    gl.useProgram(this.m_stateProgram.getProgram());
    this.makeDrawCall(this.m_spec.state);
    defaultRef.readViewport();
};

es3fVertexArrayObjectTests.VertexArrayObjectTest.prototype.iterate = function() {
    var vaoReference = new tcuSurface.Surface();
    var stateReference = new tcuSurface.Surface();
    var vaoResult = new tcuSurface.Surface();
    var stateResult = new tcuSurface.Surface();

    var isOk;

    // logVertexArrayState(m_log, m_spec.vao, "Vertex Array Object State");
    // logVertexArrayState(m_log, m_spec.state, "OpenGL Vertex Array State");
    this.genReferences(stateReference, vaoReference);
    this.render(stateResult, vaoResult);

    isOk = tcuImageCompare.pixelThresholdCompare('Results', 'Comparison result from rendering with Vertex Array State', stateReference, stateResult, [0, 0, 0, 0]);
    isOk = isOk && tcuImageCompare.pixelThresholdCompare('Results', 'Comparison result from rendering with Vertex Array Object', vaoReference, vaoResult, [0, 0, 0, 0]);

    if (!isOk)
        testFailedOptions('Result comparison failed', false);
    else
        testPassedOptions('Pass', true);

    return tcuTestCase.IterateResult.STOP;
};

/**
 * @constructor
 * @extends {tcuTestCase.DeqpTest}
 */
es3fVertexArrayObjectTests.VertexArrayObjectTests = function() {
    tcuTestCase.DeqpTest.call(this, 'vertex_array_objects', 'Vertex array object test cases');
};

es3fVertexArrayObjectTests.VertexArrayObjectTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fVertexArrayObjectTests.VertexArrayObjectTests.prototype.constructor = es3fVertexArrayObjectTests.VertexArrayObjectTests;

es3fVertexArrayObjectTests.VertexArrayObjectTests.prototype.init = function() {
    var floatCoordBuffer48_1 = new es3fVertexArrayObjectTests.BufferSpec(48, 384, 2, 0, 0, gl.FLOAT, 0, 0, -1.0, 1.0);
    var floatCoordBuffer48_2 = new es3fVertexArrayObjectTests.BufferSpec(48, 384, 2, 0, 0, gl.FLOAT, 0, 0, -1.0, 1.0);

    var shortCoordBuffer48 = new es3fVertexArrayObjectTests.BufferSpec(48, 192, 2, 0, 0, gl.SHORT, -32768, 32768, 0.0, 0.0);

    var spec;
    var state;
    // Different buffer
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.FLOAT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = false;

    state.elementArrayBuffer = 0;

    spec.buffers.push(floatCoordBuffer48_1);
    spec.buffers.push(floatCoordBuffer48_2);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 48;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.state.attributes[0].bufferNdx = 1;
    spec.vao.attributes[0].bufferNdx = 2;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_buffer', 'diff_buffer'));

    // Different size
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.FLOAT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = false;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(floatCoordBuffer48_1);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.state.attributes[0].size = 2;
    spec.vao.attributes[0].size = 3;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_size', 'diff_size'));

    // Different stride
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.SHORT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.vao.attributes[0].stride = 2;
    spec.state.attributes[0].stride = 4;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_stride', 'diff_stride'));

    // Different types
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.SHORT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.vao.attributes[0].type = gl.SHORT;
    spec.state.attributes[0].type = gl.BYTE;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_type', 'diff_type'));

    // Different "integer"
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.BYTE;
    state.attributes[0].integer = true;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = false;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);

    spec.useDrawElements = false;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.instances = 0;
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.state.attributes[0].integer = false;
    spec.vao.attributes[0].integer = true;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_integer', 'diff_integer'));

    // Different divisor
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());
    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.SHORT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.attributes[1].enabled = true;
    state.attributes[1].size = 4;
    state.attributes[1].stride = 0;
    state.attributes[1].type = gl.FLOAT;
    state.attributes[1].integer = false;
    state.attributes[1].divisor = 0;
    state.attributes[1].offset = 0;
    state.attributes[1].normalized = false;
    state.attributes[1].bufferNdx = 2;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);
    spec.buffers.push(floatCoordBuffer48_1);

    spec.useDrawElements = false;
    spec.instances = 10;
    spec.count = 12;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.vao.attributes[1].divisor = 3;
    spec.state.attributes[1].divisor = 2;

    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_divisor', 'diff_divisor'));

    // Different offset
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.SHORT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.vao.attributes[0].offset = 2;
    spec.state.attributes[0].offset = 4;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_offset', 'diff_offset'));

    // Different normalize
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.SHORT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(shortCoordBuffer48);

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 48;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;

    spec.vao.attributes[0].normalized = true;
    spec.state.attributes[0].normalized = false;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_normalize', 'diff_normalize'));

    // DrawElements with buffer
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    state.attributes.push(new es3fVertexArrayObjectTests.Attribute());

    state.attributes[0].enabled = true;
    state.attributes[0].size = 2;
    state.attributes[0].stride = 0;
    state.attributes[0].type = gl.FLOAT;
    state.attributes[0].integer = false;
    state.attributes[0].divisor = 0;
    state.attributes[0].offset = 0;
    state.attributes[0].normalized = true;
    state.attributes[0].bufferNdx = 1;

    state.elementArrayBuffer = 0;

    spec.buffers.push(floatCoordBuffer48_1);

    var indexBuffer = new es3fVertexArrayObjectTests.BufferSpec(24, 192, 1, 0, 0, gl.UNSIGNED_SHORT, 0, 47, 0.0, 0.0);
    spec.buffers.push(indexBuffer);
    spec.buffers.push(indexBuffer);

    spec.useDrawElements = true;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.instances = 0;
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 48;
    spec.indexType = gl.UNSIGNED_SHORT;
    spec.indexCount = 24;

    spec.state.elementArrayBuffer = 3;
    spec.vao.elementArrayBuffer = 2;
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'diff_indices', 'diff_indices'));

    var attribCount = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
    var random = new deRandom.Random(attribCount);
    spec = new es3fVertexArrayObjectTests.Spec();

    state = new es3fVertexArrayObjectTests.VertexArrayState();

    spec.useDrawElements = false;
    spec.instances = 0;
    spec.count = 24;
    spec.vao = state;
    spec.state = deUtil.clone(state);
    spec.indexOffset = 0;
    spec.indexRangeMin = 0;
    spec.indexRangeMax = 0;
    spec.indexType = gl.NONE;
    spec.indexCount = 0;
    spec.vao.elementArrayBuffer = 0;
    spec.state.elementArrayBuffer = 0;

    // Use all attributes
    for (var attribNdx = 0; attribNdx < attribCount; attribNdx++) {
        spec.buffers.push(shortCoordBuffer48);

        spec.state.attributes.push(new es3fVertexArrayObjectTests.Attribute());
        spec.state.attributes[attribNdx].enabled = (random.getInt(0, 4) == 0) ? false : true;
        spec.state.attributes[attribNdx].size = random.getInt(2, 4);
        spec.state.attributes[attribNdx].stride = 2 * random.getInt(1, 3);
        spec.state.attributes[attribNdx].type = gl.SHORT;
        spec.state.attributes[attribNdx].integer = random.getBool();
        spec.state.attributes[attribNdx].divisor = random.getInt(0, 1);
        spec.state.attributes[attribNdx].offset = 2 * random.getInt(0, 2);
        spec.state.attributes[attribNdx].normalized = random.getBool();
        spec.state.attributes[attribNdx].bufferNdx = attribNdx + 1;

        if (attribNdx == 0) {
            spec.state.attributes[attribNdx].divisor = 0;
            spec.state.attributes[attribNdx].enabled = true;
            spec.state.attributes[attribNdx].size = 2;
        }

        spec.vao.attributes.push(new es3fVertexArrayObjectTests.Attribute());
        spec.vao.attributes[attribNdx].enabled = (random.getInt(0, 4) == 0) ? false : true;
        spec.vao.attributes[attribNdx].size = random.getInt(2, 4);
        spec.vao.attributes[attribNdx].stride = 2 * random.getInt(1, 3);
        spec.vao.attributes[attribNdx].type = gl.SHORT;
        spec.vao.attributes[attribNdx].integer = random.getBool();
        spec.vao.attributes[attribNdx].divisor = random.getInt(0, 1);
        spec.vao.attributes[attribNdx].offset = 2 * random.getInt(0, 2);
        spec.vao.attributes[attribNdx].normalized = random.getBool();
        spec.vao.attributes[attribNdx].bufferNdx = attribCount - attribNdx;

        if (attribNdx == 0) {
            spec.vao.attributes[attribNdx].divisor = 0;
            spec.vao.attributes[attribNdx].enabled = true;
            spec.vao.attributes[attribNdx].size = 2;
        }

    }
    this.addChild(new es3fVertexArrayObjectTests.VertexArrayObjectTest(spec, 'all_attributes', 'all_attributes'));

};

/**
 * Run test
 * @param {WebGL2RenderingContext} context
 */
es3fVertexArrayObjectTests.run = function(context) {
    gl = context;
    //Set up Test Root parameters
    var state = tcuTestCase.runner;
    state.setRoot(new es3fVertexArrayObjectTests.VertexArrayObjectTests());

    //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 es3fVertexArrayObjectTests.run tests', false);
        tcuTestCase.runner.terminate();
    }
};

});