Bug 1918529 - fix some subpixel misalignment issues with gfx.webrender.svg-filter...

[gecko.git] / dom / canvas / test / webgl-conf / checkout / deqp / modules / shared / glsDrawTests.js

/*-------------------------------------------------------------------------
 * 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('modules.shared.glsDrawTests');
goog.require('framework.common.tcuFloat');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuPixelFormat');
goog.require('framework.common.tcuRGBA');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTextureUtil');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluStrUtil');
goog.require('framework.opengl.simplereference.sglrGLContext');
goog.require('framework.opengl.simplereference.sglrReferenceContext');
goog.require('framework.opengl.simplereference.sglrShaderProgram');
goog.require('framework.referencerenderer.rrFragmentOperations');
goog.require('framework.referencerenderer.rrGenericVector');
goog.require('framework.referencerenderer.rrShadingContext');
goog.require('framework.referencerenderer.rrVertexAttrib');
goog.require('framework.referencerenderer.rrVertexPacket');

goog.scope(function() {

    var glsDrawTests = modules.shared.glsDrawTests;
    var tcuTestCase = framework.common.tcuTestCase;
    var tcuRGBA = framework.common.tcuRGBA;
    var tcuFloat = framework.common.tcuFloat;
    var tcuPixelFormat = framework.common.tcuPixelFormat;
    var tcuSurface = framework.common.tcuSurface;
    var tcuImageCompare = framework.common.tcuImageCompare;
    var tcuTextureUtil = framework.common.tcuTextureUtil;
    var gluShaderUtil = framework.opengl.gluShaderUtil;
    var gluStrUtil = framework.opengl.gluStrUtil;
    var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
    var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext;
    var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram;
    var deMath = framework.delibs.debase.deMath;
    var deRandom = framework.delibs.debase.deRandom;
    var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations;
    var rrGenericVector = framework.referencerenderer.rrGenericVector;
    var rrShadingContext = framework.referencerenderer.rrShadingContext;
    var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;
    var rrVertexPacket = framework.referencerenderer.rrVertexPacket;

    /** @const {number} */ glsDrawTests.MAX_RENDER_TARGET_SIZE = 512;

    // Utils

    /**
     * @param {glsDrawTests.DrawTestSpec.Target} target
     * @return {number}
     */
    glsDrawTests.targetToGL = function(target) {
        assertMsgOptions(target != null, 'Target is null', false, true);

        var targets = [
            gl.ELEMENT_ARRAY_BUFFER, // TARGET_ELEMENT_ARRAY = 0,
            gl.ARRAY_BUFFER // TARGET_ARRAY,
        ];

        return targets[target];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Usage} usage
     * @return {number}
     */
    glsDrawTests.usageToGL = function(usage) {
        assertMsgOptions(usage != null, 'Usage is null', false, true);

        var usages = [
            gl.DYNAMIC_DRAW, // USAGE_DYNAMIC_DRAW = 0,
            gl.STATIC_DRAW, // USAGE_STATIC_DRAW,
            gl.STREAM_DRAW, // USAGE_STREAM_DRAW,

            gl.STREAM_READ, // USAGE_STREAM_READ,
            gl.STREAM_COPY, // USAGE_STREAM_COPY,

            gl.STATIC_READ, // USAGE_STATIC_READ,
            gl.STATIC_COPY, // USAGE_STATIC_COPY,

            gl.DYNAMIC_READ, // USAGE_DYNAMIC_READ,
            gl.DYNAMIC_COPY // USAGE_DYNAMIC_COPY,
        ];
        assertMsgOptions(usages.length == Object.keys(glsDrawTests.DrawTestSpec.Usage).length,
            'Amount of usage gl vlaues is different from amount of usages', false, true);

        return usages[usage];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {number}
     */
    glsDrawTests.inputTypeToGL = function(type) {
        assertMsgOptions(type != null, 'Input type is null', false, true);

        var types = [
            gl.FLOAT, // INPUTTYPE_FLOAT = 0,
            gl.BYTE, // INPUTTYPE_BYTE,
            gl.SHORT, // INPUTTYPE_SHORT,
            gl.UNSIGNED_BYTE, // INPUTTYPE_UNSIGNED_BYTE,
            gl.UNSIGNED_SHORT, // INPUTTYPE_UNSIGNED_SHORT,

            gl.INT, // INPUTTYPE_INT,
            gl.UNSIGNED_INT, // INPUTTYPE_UNSIGNED_INT,
            gl.HALF_FLOAT, // INPUTTYPE_HALF,
            gl.UNSIGNED_INT_2_10_10_10_REV, // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
            gl.INT_2_10_10_10_REV // INPUTTYPE_INT_2_10_10_10,
        ];
        assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length,
            'Amount of gl input types is different from amount of input types', false, true);

        return types[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {string}
     */
    glsDrawTests.outputTypeToGLType = function(type) {
        assertMsgOptions(type != null, 'Output type is null', false, true);

        var types = [
            'float', // OUTPUTTYPE_FLOAT = 0,
            'vec2', // OUTPUTTYPE_VEC2,
            'vec3', // OUTPUTTYPE_VEC3,
            'vec4', // OUTPUTTYPE_VEC4,

            'int', // OUTPUTTYPE_INT,
            'uint', // OUTPUTTYPE_UINT,

            'ivec2', // OUTPUTTYPE_IVEC2,
            'ivec3', // OUTPUTTYPE_IVEC3,
            'ivec4', // OUTPUTTYPE_IVEC4,

            'uvec2', // OUTPUTTYPE_UVEC2,
            'uvec3', // OUTPUTTYPE_UVEC3,
            'uvec4' // OUTPUTTYPE_UVEC4,
        ];
        assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.OutputType).length,
            'Amount of output type names is different than amount of output types', false, true);

        return types[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive
     * @return {number}
     */
    glsDrawTests.primitiveToGL = function(primitive) {
        var primitives = [
            gl.POINTS, // PRIMITIVE_POINTS = 0,
            gl.TRIANGLES, // PRIMITIVE_TRIANGLES,
            gl.TRIANGLE_FAN, // PRIMITIVE_TRIANGLE_FAN,
            gl.TRIANGLE_STRIP, // PRIMITIVE_TRIANGLE_STRIP,
            gl.LINES, // PRIMITIVE_LINES
            gl.LINE_STRIP, // PRIMITIVE_LINE_STRIP
            gl.LINE_LOOP
        ];
        assertMsgOptions(primitives.length == Object.keys(glsDrawTests.DrawTestSpec.Primitive).length,
            'Amount of gl primitive values is different than amount of primitives', false, true);

        return primitives[primitive];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType
     * @return {number}
     */
    glsDrawTests.indexTypeToGL = function(indexType) {
        var indexTypes = [
            gl.UNSIGNED_BYTE, // INDEXTYPE_BYTE = 0,
            gl.UNSIGNED_SHORT, // INDEXTYPE_SHORT,
            gl.UNSIGNED_INT // INDEXTYPE_INT,
        ];
        assertMsgOptions(indexTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length,
            'Amount of gl index types is different than amount of index types', false, true);

        return indexTypes[indexType];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType
     * @return {?glsDrawTests.DrawTestSpec.InputType}
     */
    glsDrawTests.indexTypeToInputType = function(indexType) {
        var inputTypes = [
            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE, // INDEXTYPE_BYTE = 0,
            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT, // INDEXTYPE_SHORT,
            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT // INDEXTYPE_INT,
        ];
        assertMsgOptions(inputTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length,
            'Amount of relevant input types is different than amount of index types', false, true);

        return inputTypes[indexType];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {boolean}
     */
    glsDrawTests.inputTypeIsFloatType = function(type) {
        if (type == glsDrawTests.DrawTestSpec.InputType.FLOAT)
            return true;
        if (type == glsDrawTests.DrawTestSpec.InputType.HALF)
            return true;
        return false;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {boolean}
     */
    glsDrawTests.outputTypeIsFloatType = function(type) {
        if (type == glsDrawTests.DrawTestSpec.OutputType.FLOAT ||
            type == glsDrawTests.DrawTestSpec.OutputType.VEC2 ||
            type == glsDrawTests.DrawTestSpec.OutputType.VEC3 ||
            type == glsDrawTests.DrawTestSpec.OutputType.VEC4)
            return true;

        return false;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {boolean}
     */
    glsDrawTests.outputTypeIsIntType = function(type) {
        if (type == glsDrawTests.DrawTestSpec.OutputType.INT ||
            type == glsDrawTests.DrawTestSpec.OutputType.IVEC2 ||
            type == glsDrawTests.DrawTestSpec.OutputType.IVEC3 ||
            type == glsDrawTests.DrawTestSpec.OutputType.IVEC4)
            return true;

        return false;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {boolean}
     */
    glsDrawTests.outputTypeIsUintType = function(type) {
        if (type == glsDrawTests.DrawTestSpec.OutputType.UINT ||
            type == glsDrawTests.DrawTestSpec.OutputType.UVEC2 ||
            type == glsDrawTests.DrawTestSpec.OutputType.UVEC3 ||
            type == glsDrawTests.DrawTestSpec.OutputType.UVEC4)
            return true;

        return false;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive
     * @param {number} primitiveCount
     * @return {number}
     */
    glsDrawTests.getElementCount = function(primitive, primitiveCount) {
        switch (primitive) {
            case glsDrawTests.DrawTestSpec.Primitive.POINTS: return primitiveCount;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: return primitiveCount * 3;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: return primitiveCount + 2;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: return primitiveCount + 2;
            case glsDrawTests.DrawTestSpec.Primitive.LINES: return primitiveCount * 2;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: return primitiveCount + 1;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: return (primitiveCount == 1) ? (2) : (primitiveCount);
            default:
                throw new Error('Invalid primitive');
        }
    };

    //MethodInfo

    /**
     * @typedef {{indexed: boolean, instanced: boolean, ranged: boolean, first: boolean}}
     */
    glsDrawTests.MethodInfo = {
        /** @type {boolean} */ indexed: false,
        /** @type {boolean} */ instanced: false,
        /** @type {boolean} */ ranged: false,
        /** @type {boolean} */ first: false
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method
     * @return {glsDrawTests.MethodInfo}
     */
    glsDrawTests.getMethodInfo = function(method) {
        /** @type {Array<glsDrawTests.MethodInfo>} */ var infos = [{
                indexed: false, instanced: false, ranged: false, first: true //!< DRAWMETHOD_DRAWARRAYS,
            },{
                indexed: false, instanced: true, ranged: false, first: true //!< DRAWMETHOD_DRAWARRAYS_INSTANCED,
            },{
                indexed: true, instanced: false, ranged: false, first: false //!< DRAWMETHOD_DRAWELEMENTS,
            },{
                indexed: true, instanced: false, ranged: true, first: false //!< DRAWMETHOD_DRAWELEMENTS_RANGED,
            },{
                indexed: true, instanced: true, ranged: false, first: false //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED
            }
        ];

        assertMsgOptions(infos.length == Object.keys(glsDrawTests.DrawTestSpec.DrawMethod).length,
            'Number of info names', false, true);
        assertMsgOptions(method < infos.length, 'Invalid method', false, true);
        return /** @type {glsDrawTests.MethodInfo} */ (infos[method]);
    };

    /**
     * @param {glsDrawTests.DrawTestSpec} a
     * @param {glsDrawTests.DrawTestSpec} b
     * @return {boolean}
     */
    glsDrawTests.checkSpecsShaderCompatible = function(a, b) {
        // Only the attributes matter
        if (a.attribs.length != b.attribs.length)
            return false;

        for (var ndx = 0; ndx < a.attribs.length; ++ndx) {
            // Only the output type (== shader input type) matters and the usage in the shader.

            if (a.attribs[ndx].additionalPositionAttribute != b.attribs[ndx].additionalPositionAttribute)
                return false;

            // component counts need not to match
            if (glsDrawTests.outputTypeIsFloatType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsFloatType(b.attribs[ndx].outputType))
                continue;
            if (glsDrawTests.outputTypeIsIntType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsIntType(b.attribs[ndx].outputType))
                continue;
            if (glsDrawTests.outputTypeIsUintType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsUintType(b.attribs[ndx].outputType))
                continue;

            return false;
        }

        return true;
    };

    // generate random vectors in a way that does not depend on argument evaluation order

    /**
     * @param {deRandom.Random} random
     * @return {Array<number>}
     */
    glsDrawTests.generateRandomVec4 = function(random) {
        /** @type {Array<number>} */ var retVal = [];

        for (var i = 0; i < 4; ++i)
            retVal[i] = random.getFloat();

        return retVal;
    };

    /**
     * @param {deRandom.Random} random
     * @return {Array<number>}
     */
    glsDrawTests.generateRandomIVec4 = function(random) {
        /** @type {Array<number>} */ var retVal = [];

        for (var i = 0; i < 4; ++i)
            retVal[i] = random.getInt();

        return retVal;
    };

    /**
     * @param {deRandom.Random} random
     * @return {Array<number>}
     */
    glsDrawTests.generateRandomUVec4 = function(random) {
        /** @type {Array<number>} */ var retVal = [];

        for (var i = 0; i < 4; ++i)
            retVal[i] = Math.abs(random.getInt());

        return retVal;
    };

    //GLValue

    /**
     * glsDrawTests.GLValue class
     * @constructor
     */
    glsDrawTests.GLValue = function() {
        /** @type {goog.NumberArray} */ this.m_value = [0];
        /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.m_type;
    };

    /**
     * @param {goog.TypedArray} dst
     * @param {glsDrawTests.GLValue} val
     */
    glsDrawTests.copyGLValueToArray = function(dst, val) {
        /** @type {Uint8Array} */ var dst8 = new Uint8Array(dst.buffer).subarray(dst.byteOffset, dst.byteOffset + dst.byteLength);
        /** @type {Uint8Array} */ var val8 = new Uint8Array(val.m_value.buffer); // TODO: Fix encapsulation issue
        dst8.set(val8);
    };

    /**
     * @param {goog.TypedArray} dst
     * @param {goog.TypedArray} src
     */
    glsDrawTests.copyArray = function(dst, src) {
        /** @type {Uint8Array} */ var dst8 = new Uint8Array(dst.buffer).subarray(dst.byteOffset, dst.byteOffset + dst.byteLength);
        /** @type {Uint8Array} */ var src8 = new Uint8Array(src.buffer).subarray(src.byteOffset, src.byteOffset + src.byteLength);
        dst8.set(src8);
    };

    /**
     * typeToTypedArray function. Determines which type of array will store the value, and stores it.
     * @param {number} value
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     */
    glsDrawTests.GLValue.typeToTypedArray = function(value, type) {
        var array;

        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
                array = new Float32Array(1);
                break;

            case glsDrawTests.DrawTestSpec.InputType.BYTE:
                array = new Int8Array(1);
                break;
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
                array = new Int16Array(1);
                break;

            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
                array = new Uint8Array(1);
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
                array = new Uint16Array(1);
                break;

            case glsDrawTests.DrawTestSpec.InputType.INT:
                array = new Int32Array(1);
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                array = new Uint32Array(1);
                break;
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                array = new Uint16Array(1);
                value = glsDrawTests.GLValue.floatToHalf(value);
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10:
                array = new Uint32Array(1);
                break;
            case glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10:
                array = new Int32Array(1);
                break;
            default:
                throw new Error('glsDrawTests.GLValue.typeToTypedArray - Invalid InputType');
        }

        array[0] = value;
        return array;
    };

    /**
     * glsDrawTests.GLValue.create
     * @param {number} value
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     */
    glsDrawTests.GLValue.create = function(value, type) {
        var v = new glsDrawTests.GLValue();
        v.m_value = glsDrawTests.GLValue.typeToTypedArray(value, type);
        v.m_type = type;
        return v;
    };

    /**
     * glsDrawTests.GLValue.halfToFloat
     * @param {number} value
     * @return {number}
     */
    glsDrawTests.GLValue.halfToFloat = function(value) {
        return tcuFloat.halfFloatToNumberNoDenorm(value);
    };

    /**
     * @param {number} f
     * @return {number}
     */
    glsDrawTests.GLValue.floatToHalf = function(f) {
        // No denorm support.
        return tcuFloat.numberToHalfFloatNoDenorm(f);
    };

    /**
     * glsDrawTests.GLValue.getMaxValue
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.getMaxValue = function(type) {
        var value = 0;

        assertMsgOptions(type >= 0 && type < Object.keys(glsDrawTests.DrawTestSpec.InputType).length,
            'Invalid type for GLValue', false, true);

        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
                value = 127;
                break;
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
                value = 127;
                break;
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
                value = 32760;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
                value = 255;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
                value = 65530;
                break;
            case glsDrawTests.DrawTestSpec.InputType.INT:
                value = 2147483647;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                value = 4294967295;
                break;
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                value = 256;
                break;
            default: //For any other valid type, return 0
                value = 0;
        }

        return glsDrawTests.GLValue.create(value, type);
    };

    /**
     * glsDrawTests.GLValue.getMinValue
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.getMinValue = function(type) {
        var value = 0;

        assertMsgOptions(type >= 0 && type < Object.keys(glsDrawTests.DrawTestSpec.InputType).length,
            'Invalid type for GLValue', false, true);

        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
                value = -127;
                break;
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
                value = -127;
                break;
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
                value = -32760;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
                value = 0;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
                value = 0;
                break;
            case glsDrawTests.DrawTestSpec.InputType.INT:
                value = -2147483647;
                break;
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                value = 0;
                break;
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                value = -256;
                break;
            default: //For any other valid type, return 0
                value = 0;
        }

        return glsDrawTests.GLValue.create(value, type);
    };

    /**
     * glsDrawTests.GLValue.getRandom
     * @param {deRandom.Random} rnd
     * @param {glsDrawTests.GLValue} min
     * @param {glsDrawTests.GLValue} max
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.getRandom = function(rnd, min, max) {
        assertMsgOptions(min.getType() == max.getType(), 'Min and max types differ', false, true);

        var minv = min.interpret();
        var maxv = max.interpret();
        var type = min.getType();
        var value;

        if (maxv < minv)
            return min;

        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
            case glsDrawTests.DrawTestSpec.InputType.HALF: {
                return glsDrawTests.GLValue.create(minv + rnd.getFloat() * (maxv - minv), type);
                break;
            }

            case glsDrawTests.DrawTestSpec.InputType.SHORT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
            case glsDrawTests.DrawTestSpec.InputType.INT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: {
                return glsDrawTests.GLValue.create(minv + rnd.getInt() % (maxv - minv), type);
                break;
            }

            default:
                throw new Error('glsDrawTests.GLValue.getRandom - Invalid input type');
                break;
        }
    };

    // Minimum difference required between coordinates

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.minValue = function(type) {
        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                return glsDrawTests.GLValue.create(4, type);
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
                return glsDrawTests.GLValue.create(4 * 256, type);
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
                return glsDrawTests.GLValue.create(4 * 2, type);
            case glsDrawTests.DrawTestSpec.InputType.INT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                return glsDrawTests.GLValue.create(4 * 16777216, type);

            default:
                throw new Error('glsDrawTests.GLValue.minValue - Invalid input type');
        }
    };

    /**
     * @param {glsDrawTests.GLValue} val
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.abs = function(val) {
        var type = val.getType();
        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
                return glsDrawTests.GLValue.create(0x7FFF & val.getValue(), type);
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
                return glsDrawTests.GLValue.create(0x7F & val.getValue(), type);
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                return val;
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                return glsDrawTests.GLValue.create(Math.abs(val.interpret()), type);
            case glsDrawTests.DrawTestSpec.InputType.INT:
                return glsDrawTests.GLValue.create(0x7FFFFFFF & val.getValue(), type);
            default:
                throw new Error('glsDrawTests.GLValue.abs - Invalid input type');
        }
    };

    /**
     * @return {?glsDrawTests.DrawTestSpec.InputType}
     */
    glsDrawTests.GLValue.prototype.getType = function() {
        return this.m_type;
    };

    /**
     * glsDrawTests.GLValue.toFloat
     * @return {number}
     */
    glsDrawTests.GLValue.prototype.toFloat = function() {
        return this.interpret();
    };

    /**
     * glsDrawTests.GLValue.getValue
     * @return {number}
     */
    glsDrawTests.GLValue.prototype.getValue = function() {
        return this.m_value[0];
    };

    /**
     * interpret function. Returns the m_value as a quantity so arithmetic operations can be performed on it
     * Only some types require this.
     * @return {number}
     */
    glsDrawTests.GLValue.prototype.interpret = function() {
        if (this.m_type == glsDrawTests.DrawTestSpec.InputType.HALF)
            return glsDrawTests.GLValue.halfToFloat(this.m_value[0]);

        return this.m_value[0];
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.add = function(other) {
        return glsDrawTests.GLValue.create(this.interpret() + other.interpret(), this.m_type);
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.mul = function(other) {
        return glsDrawTests.GLValue.create(this.interpret() * other.interpret(), this.m_type);
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.div = function(other) {
        return glsDrawTests.GLValue.create(this.interpret() / other.interpret(), this.m_type);
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.sub = function(other) {
        return glsDrawTests.GLValue.create(this.interpret() - other.interpret(), this.m_type);
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.addToSelf = function(other) {
        this.m_value[0] = this.interpret() + other.interpret();
        return this;
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.subToSelf = function(other) {
        this.m_value[0] = this.interpret() - other.interpret();
        return this;
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.mulToSelf = function(other) {
        this.m_value[0] = this.interpret() * other.interpret();
        return this;
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {glsDrawTests.GLValue}
     */
    glsDrawTests.GLValue.prototype.divToSelf = function(other) {
        this.m_value[0] = this.interpret() / other.interpret();
        return this;
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {boolean}
     */
    glsDrawTests.GLValue.prototype.equals = function(other) {
        return this.m_value[0] == other.getValue();
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {boolean}
     */
    glsDrawTests.GLValue.prototype.lessThan = function(other) {
        return this.interpret() < other.interpret();
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {boolean}
     */
    glsDrawTests.GLValue.prototype.greaterThan = function(other) {
        return this.interpret() > other.interpret();
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {boolean}
     */
    glsDrawTests.GLValue.prototype.lessOrEqualThan = function(other) {
        return this.interpret() <= other.interpret();
    };

    /**
     * @param {glsDrawTests.GLValue} other
     * @return {boolean}
     */
    glsDrawTests.GLValue.prototype.greaterOrEqualThan = function(other) {
        return this.interpret() >= other.interpret();
    };

    // AttriuteArray

    /**
     * AttributeArray
     * @constructor
     * @param {?glsDrawTests.DrawTestSpec.Storage} storage
     * @param {sglrGLContext.GLContext | sglrReferenceContext.ReferenceContext} context
     */
    glsDrawTests.AttributeArray = function(storage, context) {
        /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.m_storage = storage;
        /** @type {sglrGLContext.GLContext | sglrReferenceContext.ReferenceContext} */ this.m_ctx = context;
        /** @type {WebGLBuffer|sglrReferenceContext.DataBuffer|null} */ this.m_glBuffer;

        /** @type {number} */ this.m_size = 0;
        /** @type {Uint8Array} */ this.m_data; //NOTE: Used in unsupported user storage
        /** @type {number} */ this.m_componentCount;
        /** @type {boolean} */ this.m_bound = false;
        /** @type {glsDrawTests.DrawTestSpec.Target} */ this.m_target = glsDrawTests.DrawTestSpec.Target.ARRAY;
        /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.m_inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;
        /** @type {?glsDrawTests.DrawTestSpec.OutputType} */ this.m_outputType = glsDrawTests.DrawTestSpec.OutputType.VEC4;
        /** @type {boolean} */ this.m_normalize = false;
        /** @type {number} */ this.m_stride = 0;
        /** @type {number} */ this.m_offset = 0;
        /** @type {Array<number>} */ this.m_defaultAttrib;
        /** @type {number} */ this.m_instanceDivisor = 0;
        /** @type {boolean} */ this.m_isPositionAttr = false;

        if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            this.m_glBuffer = this.m_ctx.createBuffer();
        }
    };

    /** @return {number} */ glsDrawTests.AttributeArray.prototype.getComponentCount = function() {return this.m_componentCount;};

    /** @return {?glsDrawTests.DrawTestSpec.Target} */ glsDrawTests.AttributeArray.prototype.getTarget = function() {return this.m_target;};

    /** @return {?glsDrawTests.DrawTestSpec.InputType} */ glsDrawTests.AttributeArray.prototype.getInputType = function() {return this.m_inputType;};

    /** @return {?glsDrawTests.DrawTestSpec.OutputType} */ glsDrawTests.AttributeArray.prototype.getOutputType = function() {return this.m_outputType;};

    /** @return {?glsDrawTests.DrawTestSpec.Storage} */ glsDrawTests.AttributeArray.prototype.getStorageType = function() {return this.m_storage;};

    /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.getNormalized = function() {return this.m_normalize;};

    /** @return {number} */ glsDrawTests.AttributeArray.prototype.getStride = function() {return this.m_stride;};

    /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.isBound = function() {return this.m_bound;};

    /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.isPositionAttribute = function() {return this.m_isPositionAttr;};

    /**
     * @param {glsDrawTests.DrawTestSpec.Target} target
     * @param {number} size
     * @param {goog.TypedArray} ptr
     * @param {?glsDrawTests.DrawTestSpec.Usage} usage
     */
    glsDrawTests.AttributeArray.prototype.data = function(target, size, ptr, usage) {
        this.m_size = size;
        this.m_target = target;

        if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer);
            this.m_ctx.bufferData(glsDrawTests.targetToGL(target), ptr, glsDrawTests.usageToGL(usage));
        } else
            throw new Error('Wrong storage type');
    };

    /**
     * @param {glsDrawTests.DrawTestSpec.Target} target
     * @param {number} offset
     * @param {number} size
     * @param {goog.TypedArray} ptr
     */
    glsDrawTests.AttributeArray.prototype.subdata = function(target, offset, size, ptr) {
        this.m_target = target;

        if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer);

            this.m_ctx.bufferSubData(glsDrawTests.targetToGL(target), offset, size, ptr);
        } else
            throw new Error('Wrong storage type');
    };

    /**
     * @param {boolean} bound
     * @param {number} offset
     * @param {number} size
     * @param {?glsDrawTests.DrawTestSpec.InputType} inputType
     * @param {?glsDrawTests.DrawTestSpec.OutputType} outType
     * @param {boolean} normalized
     * @param {number} stride
     * @param {number} instanceDivisor
     * @param {Array<number>} defaultAttrib
     * @param {boolean} isPositionAttr
     */
    glsDrawTests.AttributeArray.prototype.setupArray = function(bound, offset, size, inputType, outType,
        normalized, stride, instanceDivisor, defaultAttrib, isPositionAttr) {
        this.m_componentCount = size;
        this.m_bound = bound;
        this.m_inputType = inputType;
        this.m_outputType = outType;
        this.m_normalize = normalized;
        this.m_stride = stride;
        this.m_offset = offset;
        this.m_defaultAttrib = defaultAttrib;
        this.m_instanceDivisor = instanceDivisor;
        this.m_isPositionAttr = isPositionAttr;
    };

    /**
     * @param {number} loc (32-bit)
     */
    glsDrawTests.AttributeArray.prototype.bindAttribute = function(loc) {
        if (!this.isBound()) {
            /** @type {Array<number>} */ var attr = this.m_defaultAttrib;
            switch (this.m_inputType) {
                case glsDrawTests.DrawTestSpec.InputType.FLOAT: {
                    switch (this.m_componentCount) {
                        case 1: this.m_ctx.vertexAttrib1f(loc, attr[0]); break;
                        case 2: this.m_ctx.vertexAttrib2f(loc, attr[0], attr[1]); break;
                        case 3: this.m_ctx.vertexAttrib3f(loc, attr[0], attr[1], attr[2]); break;
                        case 4: this.m_ctx.vertexAttrib4f(loc, attr[0], attr[1], attr[2], attr[3]); break;
                        default: throw new Error('Invalid component count'); break;
                    }
                    break;
                }
                case glsDrawTests.DrawTestSpec.InputType.INT: {
                    this.m_ctx.vertexAttribI4i(loc, attr[0], attr[1], attr[2], attr[3]);
                    break;
                }
                case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: {
                    this.m_ctx.vertexAttribI4ui(loc, attr[0], attr[1], attr[2], attr[3]);
                    break;
                }
                default:
                    throw new Error('Invalid input type');
                    break;
            }
        } else {
            /** @type {Uint8Array} */ var basePtr = null;

            if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
                this.m_ctx.bindBuffer(glsDrawTests.targetToGL(this.m_target), this.m_glBuffer);

                basePtr = null;
            } else
                throw new Error('Invalid storage type');

            if (!glsDrawTests.inputTypeIsFloatType(this.m_inputType)) {
                // Input is not float type

                if (glsDrawTests.outputTypeIsFloatType(this.m_outputType)) {
                    var size = this.m_componentCount;

                    // Output type is float type
                    this.m_ctx.vertexAttribPointer(loc, size, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_normalize, this.m_stride, this.m_offset);
                } else {
                    // Output type is int type
                    this.m_ctx.vertexAttribIPointer(loc, this.m_componentCount, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_stride, this.m_offset);
                }
            } else {
                // Input type is float type

                // Output type must be float type
                assertMsgOptions(glsDrawTests.outputTypeIsFloatType(this.m_outputType), 'Output type is not float', false, true);

                this.m_ctx.vertexAttribPointer(loc, this.m_componentCount, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_normalize,
                    this.m_stride, this.m_offset);
            }

            if (this.m_instanceDivisor)
                this.m_ctx.vertexAttribDivisor(loc, this.m_instanceDivisor);
        }
    };

    /**
     * @param {glsDrawTests.DrawTestSpec.Target} target
     */
    glsDrawTests.AttributeArray.prototype.bindIndexArray = function(target) {
        if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer);
        }
    };

    // DrawTestShaderProgram

    /**
     * @constructor
     * @extends {sglrShaderProgram.ShaderProgram}
     * @param {Array<glsDrawTests.AttributeArray>} arrays
     */
    glsDrawTests.DrawTestShaderProgram = function(arrays) {
        sglrShaderProgram.ShaderProgram.call(this, this.createProgramDeclaration(arrays));

        this.m_componentCount = [];
        this.m_isCoord = [];
        this.m_attrType = [];

        for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) {
            this.m_componentCount[arrayNdx] = this.getComponentCount(arrays[arrayNdx].getOutputType());
            this.m_isCoord[arrayNdx] = arrays[arrayNdx].isPositionAttribute();
            this.m_attrType[arrayNdx] = this.mapOutputType(arrays[arrayNdx].getOutputType());
        }
    };

    glsDrawTests.DrawTestShaderProgram.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype);
    glsDrawTests.DrawTestShaderProgram.prototype.constructor = glsDrawTests.DrawTestShaderProgram;

    /**
     * @param {Array<number>} color
     * @param {goog.NumberArray} attribValue
     * @param {number} numComponents
     * @return {Array<number>}
     */
    glsDrawTests.calcShaderColor = function(color, attribValue, numComponents) {
        switch (numComponents) {
            case 1:
                color[0] = deMath.scale(color, attribValue[0])[0];
                break;

            case 2:
                color[0] = color[0] * attribValue[0];
                color[1] = color[1] * attribValue[1];
                break;

            case 3:
                color[0] = color[0] * attribValue[0];
                color[1] = color[1] * attribValue[1];
                color[2] = color[2] * attribValue[2];
                break;

            case 4:
                color[0] = color[0] * attribValue[0] * attribValue[3];
                color[1] = color[1] * attribValue[1] * attribValue[3];
                color[2] = color[2] * attribValue[2] * attribValue[3];
                break;

            default:
                throw new Error('Invalid component count');
        }

        return color;
    };

    /**
     * @param {Array<number>} coord
     * @param {goog.NumberArray} attribValue
     * @param {number} numComponents
     * @return {Array<number>}
     */
    glsDrawTests.calcShaderCoord = function(coord, attribValue, numComponents) {
        switch (numComponents) {
            case 1:

                coord = deMath.add(coord, [attribValue[0], attribValue[0]]);
                coord[0] = coord[0];
                coord[1] = coord[1];
                break;
            case 2:
                coord = deMath.add(coord, [attribValue[0], attribValue[1]]);
                coord[0] = coord[0];
                coord[1] = coord[1];
                break;
            case 3:
                coord = deMath.add(coord, [attribValue[0] + attribValue[2], attribValue[1]]);
                coord[0] = coord[0];
                coord[1] = coord[1];
                coord[2] = coord[2];
                break;
            case 4:
                coord = deMath.add(coord, [attribValue[0] + attribValue[2], attribValue[1] + attribValue[3]]);
                coord[0] = coord[0];
                coord[1] = coord[1];
                coord[2] = coord[2];
                coord[3] = coord[3];
                break;

            default:
                throw new Error('Invalid component count');
        }

        return coord;
    };

    /**
     * @param {Array<rrVertexAttrib.VertexAttrib>} inputs
     * @param {Array<rrVertexPacket.VertexPacket>} packets
     * @param {number} numPackets
     */
    glsDrawTests.DrawTestShaderProgram.prototype.shadeVertices = function(inputs, packets, numPackets) {
        var u_coordScale = this.getUniformByName('u_coordScale').value;
        var u_colorScale = this.getUniformByName('u_colorScale').value;

        for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) {
            var varyingLocColor = 0;

            /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx];

            // Calc output color
            /** @type {Array<number>} */ var coord = [0.0, 0.0];
            /** @type {Array<number>} */ var color = [1.0, 1.0, 1.0];

            for (var attribNdx = 0; attribNdx < this.m_attrType.length; attribNdx++) {
                var numComponents = this.m_componentCount[attribNdx];
                /** @type {boolean} */ var isCoord = this.m_isCoord[attribNdx];

                var attrib = rrVertexAttrib.readVertexAttrib(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx, this.m_attrType[attribNdx]);

                if (isCoord) {
                    coord = glsDrawTests.calcShaderCoord(
                        coord,
                        attrib,
                        numComponents
                    );
                } else {
                    color = glsDrawTests.calcShaderColor(
                        color,
                        attrib,
                        numComponents
                    );
                }
            }

            // Transform position
            packet.position = [u_coordScale * coord[0], u_coordScale * coord[1], 1.0, 1.0];
            packet.pointSize = 1.0;

            // Pass color to FS
            packet.outputs[varyingLocColor] = deMath.add(deMath.scale([u_colorScale * color[0], u_colorScale * color[1], u_colorScale * color[2], 1.0], 0.5), [0.5, 0.5, 0.5, 0.5]);
        }
    };

    /**
     * @param {Array<rrFragmentOperations.Fragment>} packets
     * @param {rrShadingContext.FragmentShadingContext} context
     */
    glsDrawTests.DrawTestShaderProgram.prototype.shadeFragments = function(packets, context) {
        var varyingLocColor = 0;

        for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) {
            /** @type {rrFragmentOperations.Fragment} */ var packet = packets[packetNdx];
            packet.value = rrShadingContext.readVarying(packet, context, varyingLocColor);
        }
    };

    /**
     * @param {Array<glsDrawTests.AttributeArray>} arrays
     * @return {string}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.genVertexSource = function(arrays) {
        /** @type {Array<string>}*/ var params;
        var vertexShaderTmpl = '';

        params = this.generateShaderParams();

        vertexShaderTmpl += params['VTX_HDR'];

        for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) {
            vertexShaderTmpl += params['VTX_IN'] + ' highp ' + glsDrawTests.outputTypeToGLType(arrays[arrayNdx].getOutputType()) + ' a_' + arrayNdx + ';\n';
        }

        vertexShaderTmpl +=
            'uniform highp float u_coordScale;\n' +
            'uniform highp float u_colorScale;\n' +
            params['VTX_OUT'] + ' ' + params['COL_PRECISION'] + ' vec4 v_color;\n' +
            'void main(void)\n' +
            '{\n' +
            '\tgl_PointSize = 1.0;\n' +
            '\thighp vec2 coord = vec2(0.0, 0.0);\n' +
            '\thighp vec3 color = vec3(1.0, 1.0, 1.0);\n';

        for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) {
            var isPositionAttr = arrays[arrayNdx].isPositionAttribute();

            if (isPositionAttr) {
                switch (arrays[arrayNdx].getOutputType()) {
                    case glsDrawTests.DrawTestSpec.OutputType.FLOAT:
                    case glsDrawTests.DrawTestSpec.OutputType.INT:
                    case glsDrawTests.DrawTestSpec.OutputType.UINT:
                        vertexShaderTmpl +=
                            '\tcoord += vec2(float(a_' + arrayNdx + '), float(a_' + arrayNdx + '));\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC2:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC2:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC2:
                        vertexShaderTmpl +=
                            '\tcoord += vec2(a_' + arrayNdx + '.xy);\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC3:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC3:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC3:
                        vertexShaderTmpl +=
                            '\tcoord += vec2(a_' + arrayNdx + '.xy);\n' +
                            '\tcoord.x += float(a_' + arrayNdx + '.z);\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC4:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC4:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC4:
                        vertexShaderTmpl +=
                            '\tcoord += vec2(a_' + arrayNdx + '.xy);\n' +
                            '\tcoord += vec2(a_' + arrayNdx + '.zw);\n';
                        break;

                    default:
                        throw new Error('Invalid output type');
                        break;
                }
            } else {
                switch (arrays[arrayNdx].getOutputType()) {
                    case glsDrawTests.DrawTestSpec.OutputType.FLOAT:
                    case glsDrawTests.DrawTestSpec.OutputType.INT:
                    case glsDrawTests.DrawTestSpec.OutputType.UINT:
                        vertexShaderTmpl +=
                            '\tcolor = color * float(a_' + arrayNdx + ');\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC2:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC2:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC2:
                        vertexShaderTmpl +=
                            '\tcolor.rg = color.rg * vec2(a_' + arrayNdx + '.xy);\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC3:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC3:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC3:
                        vertexShaderTmpl +=
                            '\tcolor = color.rgb * vec3(a_' + arrayNdx + '.xyz);\n';
                        break;

                    case glsDrawTests.DrawTestSpec.OutputType.VEC4:
                    case glsDrawTests.DrawTestSpec.OutputType.IVEC4:
                    case glsDrawTests.DrawTestSpec.OutputType.UVEC4:
                        vertexShaderTmpl +=
                            '\tcolor = color.rgb * vec3(a_' + arrayNdx + '.xyz) * float(a_' + arrayNdx + '.w);\n';
                        break;

                    default:
                        throw new Error('Invalid output type');
                        break;
                }
            }
        }

        vertexShaderTmpl +=
            '\tv_color = vec4(u_colorScale * color, 1.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);\n' +
            '\tgl_Position = vec4(u_coordScale * coord, 1.0, 1.0);\n' +
            '}\n';

        return vertexShaderTmpl;
    };

    /**
     * @return {string}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.genFragmentSource = function() {
        /** @type {Array<string>} */ var params;

        params = this.generateShaderParams();

        var fragmentShaderTmpl = params['FRAG_HDR'] +
            params['FRAG_IN'] + ' ' + params['COL_PRECISION'] + ' vec4 v_color;\n' +
            'void main(void)\n' +
            '{\n' +
            '\t' + params['FRAG_COLOR'] + '= v_color;\n' +
            '}\n';

        return fragmentShaderTmpl;
    };

    /**
     * @return {Array<string>}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.generateShaderParams = function() {
        /** @type {Array<string>} */ var params = [];
        if (gluShaderUtil.isGLSLVersionSupported(gl, gluShaderUtil.GLSLVersion.V300_ES)) {
            params['VTX_IN'] = 'in';
            params['VTX_OUT'] = 'out';
            params['FRAG_IN'] = 'in';
            params['FRAG_COLOR'] = 'dEQP_FragColor';
            params['VTX_HDR'] = '#version 300 es\n';
            params['FRAG_HDR'] = '#version 300 es\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n';
            params['COL_PRECISION'] = 'mediump';
        } else if (gluShaderUtil.isGLSLVersionSupported(gl, gluShaderUtil.GLSLVersion.V100_ES)) {
            params['VTX_IN'] = 'attribute';
            params['VTX_OUT'] = 'varying';
            params['FRAG_IN'] = 'varying';
            params['FRAG_COLOR'] = 'gl_FragColor';
            params['VTX_HDR'] = '';
            params['FRAG_HDR'] = '';
            params['COL_PRECISION'] = 'mediump';
        } else
            throw new Error('Invalid GL version');

        return params;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {rrGenericVector.GenericVecType}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.mapOutputType = function(type) {
        switch (type) {
            case glsDrawTests.DrawTestSpec.OutputType.FLOAT:
            case glsDrawTests.DrawTestSpec.OutputType.VEC2:
            case glsDrawTests.DrawTestSpec.OutputType.VEC3:
            case glsDrawTests.DrawTestSpec.OutputType.VEC4:
                return rrGenericVector.GenericVecType.FLOAT;

            case glsDrawTests.DrawTestSpec.OutputType.INT:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC2:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC3:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC4:
                return rrGenericVector.GenericVecType.INT32;

            case glsDrawTests.DrawTestSpec.OutputType.UINT:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC2:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC3:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC4:
                return rrGenericVector.GenericVecType.UINT32;

            default:
                throw new Error('Invalid output type');
        }
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {number}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.getComponentCount = function(type) {
        switch (type) {
            case glsDrawTests.DrawTestSpec.OutputType.FLOAT:
            case glsDrawTests.DrawTestSpec.OutputType.INT:
            case glsDrawTests.DrawTestSpec.OutputType.UINT:
                return 1;

            case glsDrawTests.DrawTestSpec.OutputType.VEC2:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC2:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC2:
                return 2;

            case glsDrawTests.DrawTestSpec.OutputType.VEC3:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC3:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC3:
                return 3;

            case glsDrawTests.DrawTestSpec.OutputType.VEC4:
            case glsDrawTests.DrawTestSpec.OutputType.IVEC4:
            case glsDrawTests.DrawTestSpec.OutputType.UVEC4:
                return 4;

            default:
                throw new Error('Invalid output type');
        }
    };

    /**
     * @param {Array<glsDrawTests.AttributeArray>} arrays
     * @return {sglrShaderProgram.ShaderProgramDeclaration}
     */
    glsDrawTests.DrawTestShaderProgram.prototype.createProgramDeclaration = function(arrays) {
        /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var decl = new sglrShaderProgram.ShaderProgramDeclaration();

        for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++)
            decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_' + arrayNdx, this.mapOutputType(arrays[arrayNdx].getOutputType())));

        decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT));
        decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));

        decl.pushVertexSource(new sglrShaderProgram.VertexSource(this.genVertexSource(arrays)));
        decl.pushFragmentSource(new sglrShaderProgram.FragmentSource(this.genFragmentSource()));

        decl.pushUniform(new sglrShaderProgram.Uniform('u_coordScale', gluShaderUtil.DataType.FLOAT));
        decl.pushUniform(new sglrShaderProgram.Uniform('u_colorScale', gluShaderUtil.DataType.FLOAT));

        return decl;
    };

    /**
     * @typedef {glsDrawTests.RandomArrayGenerator}
     */
    glsDrawTests.RandomArrayGenerator = {};

    /**
     * @param {goog.TypedArray} data
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @param {deRandom.Random} rnd
     * @param {glsDrawTests.GLValue} min
     * @param {glsDrawTests.GLValue} max
     */
    glsDrawTests.RandomArrayGenerator.setData = function(data, type, rnd, min, max) {
        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
            case glsDrawTests.DrawTestSpec.InputType.SHORT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT:
            case glsDrawTests.DrawTestSpec.InputType.BYTE:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE:
            case glsDrawTests.DrawTestSpec.InputType.INT:
            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
            case glsDrawTests.DrawTestSpec.InputType.HALF:
                glsDrawTests.copyGLValueToArray(data, glsDrawTests.GLValue.getRandom(rnd, min, max));
                break;
            default:
                throw new Error('Invalid input type');
        }
    };

    /**
     * createBasicArray
     * @param {number} seed
     * @param {number} elementCount
     * @param {number} componentCount
     * @param {number} offset
     * @param {number} stride
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @param {number} first
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive
     * @param {?goog.TypedArray} indices
     * @param {number} indexSize
     * @return {goog.TypedArray}
     */
    glsDrawTests.RandomArrayGenerator.createArray = function(seed, elementCount, componentCount, offset, stride, type, first, primitive, indices, indexSize) {
        assertMsgOptions(componentCount >= 1 && componentCount <= 4, 'Unacceptable number of components', false, true);

        /** @type {glsDrawTests.GLValue} */ var min = glsDrawTests.GLValue.getMinValue(type);
        /** @type {glsDrawTests.GLValue} */ var max = glsDrawTests.GLValue.getMaxValue(type);

        var packed = type == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10 ||
            type == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10;
        /** @type {number} */ var limit10 = (1 << 10);
        /** @type {number} */ var limit2 = (1 << 2);


        /** @type {number} */ var componentSize = glsDrawTests.DrawTestSpec.inputTypeSize(type);
        /** @type {number} */ var elementSize = componentSize * componentCount;
        /** @type {number} */ var bufferSize = offset + Math.max(elementCount * stride, elementCount * elementSize);

        var data = new ArrayBuffer(bufferSize);
        var writePtr = new Uint8Array(data, offset);

        var previousComponentsFloat = [0, 0, 0, 0];
        var rnd = new deRandom.Random(seed);

        for (var vertexNdx = 0; vertexNdx < elementCount; vertexNdx++) {
            var components = [];

            for (var componentNdx = 0; componentNdx < componentCount; componentNdx++) {
                var getRandomComponent = function() {
                    // For packed formats we can't use GLValue
                    if (packed) {
                        if (componentNdx == 3) {
                            return rnd.getInt() % limit2;
                        } else {
                            return rnd.getInt() % limit10;
                        }
                    } else {
                        return glsDrawTests.GLValue.getRandom(rnd, min, max);
                    }
                };

                var component = getRandomComponent();
                var componentFloat = (component instanceof glsDrawTests.GLValue) ? component.toFloat() : component;

                // Try to not create vertex near previous
                if (vertexNdx != 0 && Math.abs(componentFloat - previousComponentsFloat[componentNdx]) < min.toFloat()) {
                    // Too close, try again (but only once)
                    component = getRandomComponent();
                    componentFloat = (component instanceof glsDrawTests.GLValue) ? component.toFloat() : component;
                }

                components.push(component);
                previousComponentsFloat[componentNdx] = componentFloat;
            }

            if (packed) {
                var packedValue = deMath.binaryOp(
                        deMath.shiftLeft(/** @type {Array<number>} */ (components)[3], 30), deMath.binaryOp(
                            deMath.shiftLeft(/** @type {Array<number>} */ (components)[2], 20), deMath.binaryOp(
                                deMath.shiftLeft(/** @type {Array<number>} */ (components)[1], 10), /** @type {Array<number>} */ (components)[0], deMath.BinaryOp.OR
                                ), deMath.BinaryOp.OR
                            ), deMath.BinaryOp.OR
                        );
                glsDrawTests.copyArray(writePtr, new Uint32Array([packedValue]));
            } else {
                for (var componentNdx = 0; componentNdx < componentCount; componentNdx++) {
                    glsDrawTests.copyGLValueToArray(writePtr.subarray(componentNdx * componentSize), components[componentNdx]);
                }
            }

            writePtr = writePtr.subarray(stride);
        }

        return new Uint8Array(data);
    };

    /**
     * @param {number} seed
     * @param {number} elementCount
     * @param {?glsDrawTests.DrawTestSpec.IndexType} type
     * @param {number} offset
     * @param {number} min
     * @param {number} max
     * @return {goog.TypedArray}
     */
    glsDrawTests.RandomArrayGenerator.generateIndices = function(seed, elementCount, type, offset, min, max) {
        return glsDrawTests.RandomArrayGenerator.createIndices(seed, elementCount, offset, min, max, type);
    };

    /**
     * @param {number} seed
     * @param {number} elementCount
     * @param {number} offset
     * @param {number} min
     * @param {number} max
     * @param {?glsDrawTests.DrawTestSpec.IndexType} type
     * @return {goog.TypedArray}
     */
    glsDrawTests.RandomArrayGenerator.createIndices = function(seed, elementCount, offset, min, max, type) {
        /** @type {number}*/ var elementSize = glsDrawTests.DrawTestSpec.indexTypeSize(type);
        /** @type {number}*/ var bufferSize = offset + elementCount * elementSize;

        var data = new ArrayBuffer(bufferSize);
        var writePtr = new Uint8Array(data).subarray(offset);

        var rnd = new deRandom.Random(seed);

        /* TODO: get limits for given index type --> if (min < 0 || min > std::numeric_limits<T>::max() ||
            max < 0 || max > std::numeric_limits<T>::max() ||
            min > max)
            DE_ASSERT(!"Invalid range");*/

        // JS refrast requires shuffled unique keys
        var keys = [];
        for (var key = 0; key < elementCount; key++)
            keys.push(glsDrawTests.GLValue.create(key, glsDrawTests.indexTypeToInputType(type)));

        for (var elementNdx = 0; elementNdx < elementCount; ++elementNdx) {
            var randomkey = rnd.getInt(0, keys.length - 1);
            var ndx = keys[randomkey];

            keys.splice(randomkey, 1);

            glsDrawTests.copyArray(
                writePtr.subarray(elementSize * elementNdx),
                new Uint8Array(ndx.m_value.buffer)
            );
        }

        return new Uint8Array(data);
    };

    /**
     * @param {number} seed
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {Array<number>}
     */
    glsDrawTests.RandomArrayGenerator.generateAttributeValue = function(seed, type) {
        var random = new deRandom.Random(seed);

        switch (type) {
            case glsDrawTests.DrawTestSpec.InputType.FLOAT:
                return glsDrawTests.generateRandomVec4(random);

            case glsDrawTests.DrawTestSpec.InputType.INT:
                return glsDrawTests.generateRandomIVec4(random);

            case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT:
                return glsDrawTests.generateRandomUVec4(random);

            default:
                throw new Error('Invalid attribute type');
        }
    };

    // AttributePack

    /**
     * @param {sglrReferenceContext.ReferenceContext | sglrGLContext.GLContext} drawContext
     * @param {Array<number>} screenSize (2 positive elements in array)
     * @param {boolean} useVao
     * @param {boolean} logEnabled
     * @constructor
     */
    glsDrawTests.AttributePack = function(drawContext, screenSize, useVao, logEnabled) {
        /** @type {sglrReferenceContext.ReferenceContext | sglrGLContext.GLContext} */ this.m_ctx = drawContext;

        /** @type {Array<glsDrawTests.AttributeArray>} */ this.m_arrays = [];
        /** @type {sglrShaderProgram.ShaderProgram} */ this.m_program;
        /** @type {tcuSurface.Surface} */ this.m_screen = new tcuSurface.Surface(screenSize[0], screenSize[1]);
        /** @type {boolean} */ this.m_useVao = useVao;
        /** @type {boolean} */ this.m_logEnabled = logEnabled;
        /** @type {WebGLProgram | sglrShaderProgram.ShaderProgram | null} */ this.m_programID = null;
        /** @type {WebGLVertexArrayObject|sglrReferenceContext.VertexArray|null} */ this.m_vaoID = null;

        if (this.m_useVao)
            this.m_vaoID = this.m_ctx.createVertexArray();
    };

    /**
     * @return {tcuSurface.Surface}
     */
    glsDrawTests.AttributePack.prototype.getSurface = function() {
        return this.m_screen;
    };

    /**
     * @param {number} i
     * @return {glsDrawTests.AttributeArray}
     */
    glsDrawTests.AttributePack.prototype.getArray = function(i) {
        return this.m_arrays[i];
    };

    /**
     * @return number
     */
    glsDrawTests.AttributePack.prototype.getArrayCount = function() {
        return this.m_arrays.length;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Storage} storage
     */
    glsDrawTests.AttributePack.prototype.newArray = function(storage) {
        this.m_arrays.push(new glsDrawTests.AttributeArray(storage, this.m_ctx));
    };

    /**
     * clearArrays
     */
    glsDrawTests.AttributePack.prototype.clearArrays = function() {
        this.m_arrays.length = 0;
    };

    /**
     * updateProgram
     */
    glsDrawTests.AttributePack.prototype.updateProgram = function() {
        if (this.m_programID)
            this.m_ctx.deleteProgram(this.m_programID);

        this.m_program = new glsDrawTests.DrawTestShaderProgram(this.m_arrays);
        this.m_programID = this.m_ctx.createProgram(this.m_program);
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive
     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod
     * @param {number} firstVertex
     * @param {number} vertexCount
     * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType
     * @param {number} indexOffset
     * @param {number} rangeStart
     * @param {number} rangeEnd
     * @param {number} instanceCount
     * @param {number} coordScale
     * @param {number} colorScale
     * @param {glsDrawTests.AttributeArray} indexArray
     */
    glsDrawTests.AttributePack.prototype.render = function(primitive, drawMethod, firstVertex, vertexCount, indexType,
        indexOffset, rangeStart, rangeEnd, instanceCount, coordScale, colorScale, indexArray) {
        assertMsgOptions(this.m_program != null, 'Program is null', false, true);
        assertMsgOptions(this.m_programID != null, 'No context created program', false, true);

        this.m_ctx.viewport(0, 0, this.m_screen.getWidth(), this.m_screen.getHeight());
        this.m_ctx.clearColor(0.0, 0.0, 0.0, 1.0);
        this.m_ctx.clear(gl.COLOR_BUFFER_BIT);

        this.m_ctx.useProgram(this.m_programID);

        this.m_ctx.uniform1f(this.m_ctx.getUniformLocation(this.m_programID, 'u_coordScale'), coordScale);
        this.m_ctx.uniform1f(this.m_ctx.getUniformLocation(this.m_programID, 'u_colorScale'), colorScale);

        if (this.m_useVao)
            this.m_ctx.bindVertexArray(this.m_vaoID);

        if (indexArray)
            indexArray.bindIndexArray(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY);

        for (var arrayNdx = 0; arrayNdx < this.m_arrays.length; arrayNdx++) {
            var attribName = '';
            attribName += 'a_' + arrayNdx;

            var loc = this.m_ctx.getAttribLocation(this.m_programID, attribName);

            if (this.m_arrays[arrayNdx].isBound())
                this.m_ctx.enableVertexAttribArray(loc);

            this.m_arrays[arrayNdx].bindAttribute(loc);
        }

        if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS)
            this.m_ctx.drawArrays(glsDrawTests.primitiveToGL(primitive), firstVertex, vertexCount);
        else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED)
            this.m_ctx.drawArraysInstanced(glsDrawTests.primitiveToGL(primitive), firstVertex, vertexCount, instanceCount);
        else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS)
            this.m_ctx.drawElements(glsDrawTests.primitiveToGL(primitive), vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset);
        else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED)
            this.m_ctx.drawRangeElements(glsDrawTests.primitiveToGL(primitive), rangeStart, rangeEnd, vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset);
        else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED)
            this.m_ctx.drawElementsInstanced(glsDrawTests.primitiveToGL(primitive), vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset, instanceCount);
        else
            throw new Error('Invalid draw method');

        for (var arrayNdx = 0; arrayNdx < this.m_arrays.length; arrayNdx++) {
            if (this.m_arrays[arrayNdx].isBound()) {
                var attribName = '';
                attribName += 'a_' + arrayNdx;

                var loc = this.m_ctx.getAttribLocation(this.m_programID, attribName);

                this.m_ctx.disableVertexAttribArray(loc);
            }
        }

        if (this.m_useVao)
            this.m_ctx.bindVertexArray(null);

        this.m_ctx.useProgram(null);
        this.m_screen.readViewport(this.m_ctx, [0 , 0, this.m_screen.getWidth(), this.m_screen.getHeight()]);
    };

    // DrawTestSpec

    /**
     * @constructor
     */
    glsDrawTests.DrawTestSpec = function() {
        /** @type {?glsDrawTests.DrawTestSpec.Primitive} */ this.primitive = null;
        /** @type {number} */ this.primitiveCount = 0; //!< number of primitives to draw (per instance)

        /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.drawMethod = null;
        /** @type {?glsDrawTests.DrawTestSpec.IndexType} */ this.indexType = null; //!< used only if drawMethod = DrawElements*
        /** @type {number} */ this.indexPointerOffset = 0; //!< used only if drawMethod = DrawElements*
        /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.indexStorage = null; //!< used only if drawMethod = DrawElements*
        /** @type {number} */ this.first = 0; //!< used only if drawMethod = DrawArrays*
        /** @type {number} */ this.indexMin = 0; //!< used only if drawMethod = Draw*Ranged
        /** @type {number} */ this.indexMax = 0; //!< used only if drawMethod = Draw*Ranged
        /** @type {number} */ this.instanceCount = 0; //!< used only if drawMethod = Draw*Instanced or Draw*Indirect
        /** @type {number} */ this.indirectOffset = 0; //!< used only if drawMethod = Draw*Indirect
        /** @type {number} */ this.baseVertex = 0; //!< used only if drawMethod = DrawElementsIndirect or *BaseVertex

        /** @type {Array<glsDrawTests.DrawTestSpec.AttributeSpec>} */ this.attribs = [];
    };

    /**
     * @param {glsDrawTests.DrawTestSpec.Target} target
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.targetToString = function(target) {
        assertMsgOptions(target != null, 'Target is null', false, true);

        var targets = [
            'element_array', // TARGET_ELEMENT_ARRAY = 0,
            'array' // TARGET_ARRAY,
        ];
        assertMsgOptions(targets.length == Object.keys(glsDrawTests.DrawTestSpec.Target).length,
            'The amount of target names is different than the amount of targets', false, true);

        return targets[target];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.inputTypeToString = function(type) {
        assertMsgOptions(type != null, 'Type is null', false, true);

        var types = [
            'float', // INPUTTYPE_FLOAT = 0,

            'byte', // INPUTTYPE_BYTE,
            'short', // INPUTTYPE_SHORT,

            'unsigned_byte', // INPUTTYPE_UNSIGNED_BYTE,
            'unsigned_short', // INPUTTYPE_UNSIGNED_SHORT,

            'int', // INPUTTYPE_INT,
            'unsigned_int', // INPUTTYPE_UNSIGNED_INT,
            'half', // INPUTTYPE_HALF,
            'unsigned_int2_10_10_10', // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
            'int2_10_10_10' // INPUTTYPE_INT_2_10_10_10,
        ];
        assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length,
            'The amount of type names is different than the amount of types', false, true);

        return types[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.OutputType} type
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.outputTypeToString = function(type) {
        assertMsgOptions(type != null, 'Type is null', false, true);

        var types = [
            'float', // OUTPUTTYPE_FLOAT = 0,
            'vec2', // OUTPUTTYPE_VEC2,
            'vec3', // OUTPUTTYPE_VEC3,
            'vec4', // OUTPUTTYPE_VEC4,

            'int', // OUTPUTTYPE_INT,
            'uint', // OUTPUTTYPE_UINT,

            'ivec2', // OUTPUTTYPE_IVEC2,
            'ivec3', // OUTPUTTYPE_IVEC3,
            'ivec4', // OUTPUTTYPE_IVEC4,

            'uvec2', // OUTPUTTYPE_UVEC2,
            'uvec3', // OUTPUTTYPE_UVEC3,
            'uvec4' // OUTPUTTYPE_UVEC4,
        ];
        assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.OutputType).length,
            'The amount of type names is different than the amount of types', false, true);

        return types[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Usage} usage
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.usageTypeToString = function(usage) {
        assertMsgOptions(usage != null, 'Usage is null', false, true);

        var usages = [
            'dynamic_draw', // USAGE_DYNAMIC_DRAW = 0,
            'static_draw', // USAGE_STATIC_DRAW,
            'stream_draw', // USAGE_STREAM_DRAW,

            'stream_read', // USAGE_STREAM_READ,
            'stream_copy', // USAGE_STREAM_COPY,

            'static_read', // USAGE_STATIC_READ,
            'static_copy', // USAGE_STATIC_COPY,

            'dynamic_read', // USAGE_DYNAMIC_READ,
            'dynamic_copy' // USAGE_DYNAMIC_COPY,
        ];
        assertMsgOptions(usages.length == Object.keys(glsDrawTests.DrawTestSpec.Usage).length,
            'The amount of usage names is different than the amount of usages', false, true);

        return usages[usage];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Storage} storage
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.storageToString = function(storage) {
        assertMsgOptions(storage != null, 'Storage is null', false, true);

        var storages = [
            'user_ptr', // STORAGE_USER = 0,
            'buffer' // STORAGE_BUFFER,
        ];
        assertMsgOptions(storages.length == Object.keys(glsDrawTests.DrawTestSpec.Storage).length,
            'The amount of storage names is different than the amount of storages', false, true);

        return storages[storage];
    };

    /**
     * @param {glsDrawTests.DrawTestSpec.Primitive} primitive
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.primitiveToString = function(primitive) {
        assertMsgOptions(primitive != null, 'Primitive is null', false, true);

        var primitives = [
            'points', // PRIMITIVE_POINTS ,
            'triangles', // PRIMITIVE_TRIANGLES,
            'triangle_fan', // PRIMITIVE_TRIANGLE_FAN,
            'triangle_strip', // PRIMITIVE_TRIANGLE_STRIP,
            'lines', // PRIMITIVE_LINES
            'line_strip', // PRIMITIVE_LINE_STRIP
            'line_loop'
        ];
        assertMsgOptions(primitives.length == Object.keys(glsDrawTests.DrawTestSpec.Primitive).length,
            'The amount of primitive names is different than the amount of primitives', false, true);

        return primitives[primitive];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.IndexType} type
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.indexTypeToString = function(type) {
        assertMsgOptions(type != null, 'Index type is null', false, true);

        var indexTypes = [
            'byte', // INDEXTYPE_BYTE = 0,
            'short', // INDEXTYPE_SHORT,
            'int' // INDEXTYPE_INT,
        ];
        assertMsgOptions(indexTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length,
            'The amount of index type names is different than the amount of index types', false, true);

        return indexTypes[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.drawMethodToString = function(method) {
        assertMsgOptions(method != null, 'Method is null', false, true);

        var methods = [
            'draw_arrays', //!< DRAWMETHOD_DRAWARRAYS
            'draw_arrays_instanced', //!< DRAWMETHOD_DRAWARRAYS_INSTANCED
            'draw_elements', //!< DRAWMETHOD_DRAWELEMENTS
            'draw_range_elements', //!< DRAWMETHOD_DRAWELEMENTS_RANGED
            'draw_elements_instanced' //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED
        ];
        assertMsgOptions(methods.length == Object.keys(glsDrawTests.DrawTestSpec.DrawMethod).length,
        'The amount of method names is different than the amount of methods', false, true);

        return methods[method];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} type
     * @return {number}
     */
    glsDrawTests.DrawTestSpec.inputTypeSize = function(type) {
        assertMsgOptions(type != null, 'Input type is null', false, true);

        var size = [
            4, // INPUTTYPE_FLOAT = 0,

            1, // INPUTTYPE_BYTE,
            2, // INPUTTYPE_SHORT,

            1, // INPUTTYPE_UNSIGNED_BYTE,
            2, // INPUTTYPE_UNSIGNED_SHORT,

            4, // INPUTTYPE_INT,
            4, // INPUTTYPE_UNSIGNED_INT,
            2, // INPUTTYPE_HALF,
            4 / 4, // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
            4 / 4 // INPUTTYPE_INT_2_10_10_10,
        ];
        assertMsgOptions(size.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length,
            'The amount of type names is different than the amount of types', false, true);

        return size[type];
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.IndexType} type
     * @return {number}
     */
    glsDrawTests.DrawTestSpec.indexTypeSize = function(type) {
        assertMsgOptions(type != null, 'Type is null', false, true);

        var size = [
            1, // INDEXTYPE_BYTE,
            2, // INDEXTYPE_SHORT,
            4 // INDEXTYPE_INT,
        ];
        assertMsgOptions(size.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length,
            'The amount of type names is different than the amount of types', false, true);

        return size[type];
    };

    /**
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.prototype.getName = function() {
        /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod);
        /** @type {boolean} */ var hasFirst = methodInfo.first;
        /** @type {boolean} */ var instanced = methodInfo.instanced;
        /** @type {boolean} */ var ranged = methodInfo.ranged;
        /** @type {boolean} */ var indexed = methodInfo.indexed;

        var name = '';

        for (var ndx = 0; ndx < this.attribs.length; ++ndx) {
            /** @type {glsDrawTests.DrawTestSpec.AttributeSpec}*/ var attrib = this.attribs[ndx];

            if (this.attribs.length > 1)
                name += 'attrib' + ndx + '_';

            if (ndx == 0 || attrib.additionalPositionAttribute)
                name += 'pos_';
            else
                name += 'col_';

            if (attrib.useDefaultAttribute) {
                name += 'non_array_' +
                    glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '_' +
                    attrib.componentCount + '_' +
                    glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '_';
            } else {
                name += glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + '_' +
                    attrib.offset + '_' +
                    attrib.stride + '_' +
                    glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType));
                if (attrib.inputType != glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 && attrib.inputType != glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10)
                    name += attrib.componentCount;
                name += '_' +
                    (attrib.normalize ? 'normalized_' : '') +
                    glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '_' +
                    glsDrawTests.DrawTestSpec.usageTypeToString(attrib.usage) + '_' +
                    attrib.instanceDivisor + '_';
            }
        }

        if (indexed)
            name += 'index_' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '_' +
                glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '_' +
                'offset' + this.indexPointerOffset + '_';
        if (hasFirst)
            name += 'first' + this.first + '_';
        if (ranged)
            name += 'ranged_' + this.indexMin + '_' + this.indexMax + '_';
        if (instanced)
            name += 'instances' + this.instanceCount + '_';

        switch (this.primitive) {
            case glsDrawTests.DrawTestSpec.Primitive.POINTS:
                name += 'points_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES:
                name += 'triangles_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN:
                name += 'triangle_fan_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP:
                name += 'triangle_strip_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINES:
                name += 'lines_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP:
                name += 'line_strip_';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP:
                name += 'line_loop_';
                break;
            default:
                throw new Error('Invalid primitive');
                break;
        }

        name += this.primitiveCount;

        return name;
    };

    /**
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.prototype.getDesc = function() {
        var desc = '';

        for (var ndx = 0; ndx < this.attribs.length; ++ndx) {
            /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attrib = this.attribs[ndx];

            if (attrib.useDefaultAttribute) {
                desc += 'Attribute ' + ndx + ': default, ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position ,') : ('color ,')) +
                    'input datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + ', ' +
                    'input component count ' + attrib.componentCount + ', ' +
                    'used as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + ', ';
            } else {
                desc += 'Attribute ' + ndx + ': ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position ,') : ('color ,')) +
                    'Storage in ' + glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + ', ' +
                    'stride ' + attrib.stride + ', ' +
                    'input datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + ', ' +
                    'input component count ' + attrib.componentCount + ', ' +
                    (attrib.normalize ? 'normalized, ' : '') +
                    'used as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + ', ' +
                    'instance divisor ' + attrib.instanceDivisor + ', ';
            }
        }

        if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) {
            desc += 'drawArrays(), ' +
                'first ' + this.first + ', ';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED) {
            desc += 'drawArraysInstanced(), ' +
                'first ' + this.first + ', ' +
                'instance count ' + this.instanceCount + ', ';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) {
            desc += 'drawElements(), ' +
                'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' +
                'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' +
                'index offset ' + this.indexPointerOffset + ', ';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) {
            desc += 'drawElementsRanged(), ' +
                'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' +
                'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' +
                'index offset ' + this.indexPointerOffset + ', ' +
                'range start ' + this.indexMin + ', ' +
                'range end ' + this.indexMax + ', ';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) {
            desc += 'drawElementsInstanced(), ' +
                'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' +
                'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' +
                'index offset ' + this.indexPointerOffset + ', ' +
                'instance count ' + this.instanceCount + ', ';
        } else
            throw new Error('Invalid draw method');

        desc += this.primitiveCount;

        switch (this.primitive) {
            case glsDrawTests.DrawTestSpec.Primitive.POINTS:
                desc += 'points';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES:
                desc += 'triangles';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN:
                desc += 'triangles (fan)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP:
                desc += 'triangles (strip)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINES:
                desc += 'lines';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP:
                desc += 'lines (strip)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP:
                desc += 'lines (loop)';
                break;
            default:
                throw new Error('Invalid primitive');
                break;
        }

        return desc;
    };

    /**
     * @return {string}
     */
    glsDrawTests.DrawTestSpec.prototype.getMultilineDesc = function() {
        var desc = '';

        for (var ndx = 0; ndx < this.attribs.length; ++ndx) {
            /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attrib = this.attribs[ndx];

            if (attrib.useDefaultAttribute) {
                desc += 'Attribute ' + ndx + ': default, ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position\n') : ('color\n')) +
                    '\tinput datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '\n' +
                    '\tinput component count ' + attrib.componentCount + '\n' +
                    '\tused as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '\n';
            } else {
                desc += 'Attribute ' + ndx + ': ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position\n') : ('color\n')) +
                    '\tStorage in ' + glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + '\n' +
                    '\tstride ' + attrib.stride + '\n' +
                    '\tinput datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '\n' +
                    '\tinput component count ' + attrib.componentCount + '\n' +
                    (attrib.normalize ? '\tnormalized\n' : '') +
                    '\tused as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '\n' +
                    '\tinstance divisor ' + attrib.instanceDivisor + '\n';
            }
        }

        if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) {
            desc += 'drawArrays()\n' +
                '\tfirst ' + this.first + '\n';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED) {
            desc += 'drawArraysInstanced()\n' +
                '\tfirst ' + this.first + '\n' +
                '\tinstance count ' + this.instanceCount + '\n';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) {
            desc += 'drawElements()\n' +
                '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' +
                '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' +
                '\tindex offset ' + this.indexPointerOffset + '\n';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) {
            desc += 'drawElementsRanged()\n' +
                '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' +
                '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' +
                '\tindex offset ' + this.indexPointerOffset + '\n' +
                '\trange start ' + this.indexMin + '\n' +
                '\trange end ' + this.indexMax + '\n';
        } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) {
            desc += 'drawElementsInstanced()\n' +
                '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' +
                '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' +
                '\tindex offset ' + this.indexPointerOffset + '\n' +
                '\tinstance count ' + this.instanceCount + '\n';
        } else
            throw new Error('Invalid draw method');

        desc += '\t' + this.primitiveCount + ' ';

        switch (this.primitive) {
            case glsDrawTests.DrawTestSpec.Primitive.POINTS:
                desc += 'points';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES:
                desc += 'triangles';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN:
                desc += 'triangles (fan)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP:
                desc += 'triangles (strip)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINES:
                desc += 'lines';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP:
                desc += 'lines (strip)';
                break;
            case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP:
                desc += 'lines (loop)';
                break;
            default:
                throw new Error('Invalid primitive');
                break;
        }

        desc += '\n';

        return desc;
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.Target = {
        ELEMENT_ARRAY: 0,
        ARRAY: 1
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.InputType = {
        FLOAT: 0,

        BYTE: 1,
        SHORT: 2,

        UNSIGNED_BYTE: 3,
        UNSIGNED_SHORT: 4,

        INT: 5,
        UNSIGNED_INT: 6,
        HALF: 7,
        UNSIGNED_INT_2_10_10_10: 8,
        INT_2_10_10_10: 9
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.OutputType = {
        FLOAT: 0,
        VEC2: 1,
        VEC3: 2,
        VEC4: 3,

        INT: 4,
        UINT: 5,

        IVEC2: 6,
        IVEC3: 7,
        IVEC4: 8,

        UVEC2: 9,
        UVEC3: 10,
        UVEC4: 11
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.Usage = {
        DYNAMIC_DRAW: 0,
        STATIC_DRAW: 1,
        STREAM_DRAW: 2,

        STREAM_READ: 3,
        STREAM_COPY: 4,

        STATIC_READ: 5,
        STATIC_COPY: 6,

        DYNAMIC_READ: 7,
        DYNAMIC_COPY: 8
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.Storage = {
        USER: 0,
        BUFFER: 1
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.Primitive = {
        POINTS: 0,
        TRIANGLES: 1,
        TRIANGLE_FAN: 2,
        TRIANGLE_STRIP: 3,
        LINES: 4,
        LINE_STRIP: 5,
        LINE_LOOP: 6
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.IndexType = {
        BYTE: 0,
        SHORT: 1,
        INT: 2
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.DrawMethod = {
         DRAWARRAYS: 0,
         DRAWARRAYS_INSTANCED: 1,
         DRAWELEMENTS: 2,
         DRAWELEMENTS_RANGED: 3,
         DRAWELEMENTS_INSTANCED: 4
    };

    /**
     * @enum {number}
     */
    glsDrawTests.DrawTestSpec.CompatibilityTestType = {
        NONE: 0,
        UNALIGNED_OFFSET: 1,
        UNALIGNED_STRIDE: 2
    };

    /**
     * @return {number}
     */
    glsDrawTests.DrawTestSpec.prototype.hash = function() {
        // Use only drawmode-relevant values in "hashing" as the unrelevant values might not be set (causing non-deterministic behavior).
        /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod);
        /** @type {boolean} */ var arrayed = methodInfo.first;
        /** @type {boolean} */ var instanced = methodInfo.instanced;
        /** @type {boolean} */ var ranged = methodInfo.ranged;
        /** @type {boolean} */ var indexed = methodInfo.indexed;

        /** @type {number} */ var indexHash = (!indexed) ? (0) : (this.indexType + 10 * this.indexPointerOffset + 100 * this.indexStorage);
        /** @type {number} */ var arrayHash = (!arrayed) ? (0) : (this.first);
        /** @type {number} */ var indexRangeHash = (!ranged) ? (0) : (this.indexMin + 10 * this.indexMax);
        /** @type {number} */ var instanceHash = (!instanced) ? (0) : (this.instanceCount);
        /** @type {number} */ var basicHash = this.primitive + 10 * this.primitiveCount + 100 * this.drawMethod;

        return indexHash + 3 * arrayHash + 5 * indexRangeHash + 7 * instanceHash + 13 * basicHash + 17 * this.attribs.length + 19 * this.primitiveCount;
    };

    /**
     * @return {boolean}
     */
    glsDrawTests.DrawTestSpec.prototype.valid = function() {
        assertMsgOptions(this.primitive != null, 'Primitive is null', false, true);
        assertMsgOptions(this.drawMethod != null, 'Draw method is null', false, true);

        var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod);

        if (methodInfo.ranged) {
            var maxIndexValue = 0;
            if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.BYTE)
                maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE).interpret();
            else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.SHORT)
                maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT).interpret();
            else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.INT)
                maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT).interpret();
            else
                throw new Error('Invalid index type');

            if (this.indexMin > this.indexMax)
                return false;
            if (this.indexMin < 0 || this.indexMax < 0)
                return false;
            if (this.indexMin > maxIndexValue || this.indexMax > maxIndexValue)
                return false;
        }

        if (methodInfo.first && this.first < 0)
            return false;

        return true;
    };

    /**
     * @return {glsDrawTests.DrawTestSpec.CompatibilityTestType}
     */
    glsDrawTests.DrawTestSpec.prototype.isCompatibilityTest = function() {
        var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod);

        var bufferAlignmentBad = false;
        var strideAlignmentBad = false;

        // Attribute buffer alignment
        for (var ndx = 0; ndx < this.attribs.length; ++ndx)
            if (!this.attribs[ndx].isBufferAligned())
                bufferAlignmentBad = true;

        // Attribute stride alignment
        for (var ndx = 0; ndx < this.attribs.length; ++ndx)
            if (!this.attribs[ndx].isBufferStrideAligned())
                strideAlignmentBad = true;

        // Index buffer alignment
        if (methodInfo.indexed) {
            if (this.indexStorage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
                var indexSize = 0;
                if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.BYTE)
                    indexSize = 1;
                else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.SHORT)
                    indexSize = 2;
                else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.INT)
                    indexSize = 4;
                else
                    throw new Error('');

                if (this.indexPointerOffset % indexSize != 0)
                    bufferAlignmentBad = true;
            }
        }

        // \note combination bad alignment & stride is treated as bad offset
        if (bufferAlignmentBad)
            return glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET;
        else if (strideAlignmentBad)
            return glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE;
        else
            return glsDrawTests.DrawTestSpec.CompatibilityTestType.NONE;
    };

    // DrawTestSpec.AttributeSpec

    /**
     * @constructor
     */
    glsDrawTests.DrawTestSpec.AttributeSpec = function() {
        /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.inputType = null;
        /** @type {?glsDrawTests.DrawTestSpec.OutputType} */ this.outputType = null;
        /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; //Always BUFFER in WebGL up to 2
        /** @type {?glsDrawTests.DrawTestSpec.Usage} */ this.usage = null;
        /** @type {number} */ this.componentCount = 0;
        /** @type {number} */ this.offset = 0;
        /** @type {number} */ this.stride = 0;
        /** @type {boolean} */ this.normalize = false;
        /** @type {number} */ this.instanceDivisor = 0; //!< used only if drawMethod = Draw*Instanced
        /** @type {boolean} */ this.useDefaultAttribute = false;

        /** @type {boolean} */ this.additionalPositionAttribute = false; //!< treat this attribute as position attribute. Attribute at index 0 is alway treated as such. False by default
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} inputType
     * @param {?glsDrawTests.DrawTestSpec.OutputType} outputType
     * @param {?glsDrawTests.DrawTestSpec.Storage} storage
     * @param {?glsDrawTests.DrawTestSpec.Usage} usage
     * @param {number} componentCount
     * @param {number} offset
     * @param {number} stride
     * @param {boolean} normalize
     * @param {number} instanceDivisor
     * @return {glsDrawTests.DrawTestSpec.AttributeSpec}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.createAttributeArray = function(inputType, outputType, storage, usage, componentCount,
        offset, stride, normalize, instanceDivisor) {
        /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var spec;

        spec.inputType = inputType;
        spec.outputType = outputType;
        spec.storage = storage;
        spec.usage = usage;
        spec.componentCount = componentCount;
        spec.offset = offset;
        spec.stride = stride;
        spec.normalize = normalize;
        spec.instanceDivisor = instanceDivisor;

        spec.useDefaultAttribute = false;

        return spec;
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.InputType} inputType
     * @param {?glsDrawTests.DrawTestSpec.OutputType} outputType
     * @param {number} componentCount
     * @return {glsDrawTests.DrawTestSpec.AttributeSpec}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.createDefaultAttribute = function(inputType, outputType, componentCount) {
        assertMsgOptions(inputType == glsDrawTests.DrawTestSpec.InputType.INT || inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT || inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT, 'Invalid input type', false, true);
        assertMsgOptions(inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT || componentCount == 4, 'If not float, input type should have 4 components', false, true);

        /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var spec;

        spec.inputType = inputType;
        spec.outputType = outputType;
        spec.storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; //Always BUFFER in WebGL up to 2
        spec.usage = null;
        spec.componentCount = componentCount;
        spec.offset = 0;
        spec.stride = 0;
        spec.normalize = false;
        spec.instanceDivisor = 0;

        spec.useDefaultAttribute = true;

        return spec;
    };

    /**
     * @return {number}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.prototype.hash = function() {
        if (this.useDefaultAttribute) {
            return 1 * this.inputType + 7 * this.outputType + 13 * this.componentCount;
        } else {
            return 1 * this.inputType + 2 * this.outputType + 3 * this.storage + 5 * this.usage + 7 * this.componentCount + 11 * this.offset + 13 * this.stride + 17 * (this.normalize ? 0 : 1) + 19 * this.instanceDivisor;
        }
    };

    /**
     * @return {boolean}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.prototype.valid = function(/*ctxType*/) {
        /** @type {boolean} */ var inputTypeFloat = this.inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT || this.inputType == glsDrawTests.DrawTestSpec.InputType.HALF;
        /** @type {boolean} */ var inputTypeUnsignedInteger = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10;
        /** @type {boolean} */ var inputTypeSignedInteger = this.inputType == glsDrawTests.DrawTestSpec.InputType.BYTE || this.inputType == glsDrawTests.DrawTestSpec.InputType.SHORT || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10;
        /** @type {boolean} */ var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10;

        /** @type {boolean} */ var outputTypeFloat = this.outputType == glsDrawTests.DrawTestSpec.OutputType.FLOAT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4;
        /** @type {boolean} */ var outputTypeSignedInteger = this.outputType == glsDrawTests.DrawTestSpec.OutputType.INT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4;
        /** @type {boolean} */ var outputTypeUnsignedInteger = this.outputType == glsDrawTests.DrawTestSpec.OutputType.UINT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4;

        if (this.useDefaultAttribute) {
            if (this.inputType != glsDrawTests.DrawTestSpec.InputType.INT && this.inputType != glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT && this.inputType != glsDrawTests.DrawTestSpec.InputType.FLOAT)
                return false;

            if (this.inputType != glsDrawTests.DrawTestSpec.InputType.FLOAT && this.componentCount != 4)
                return false;

            // no casting allowed (undefined results)
            if (this.inputType == glsDrawTests.DrawTestSpec.InputType.INT && !outputTypeSignedInteger)
                return false;
            if (this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT && !outputTypeUnsignedInteger)
                return false;
        }

        if (inputTypePacked && this.componentCount != 4)
            return false;

        // Invalid conversions:

        // float -> [u]int
        if (inputTypeFloat && !outputTypeFloat)
            return false;

        // uint -> int (undefined results)
        if (inputTypeUnsignedInteger && outputTypeSignedInteger)
            return false;

        // int -> uint (undefined results)
        if (inputTypeSignedInteger && outputTypeUnsignedInteger)
            return false;

        // packed -> non-float (packed formats are converted to floats)
        if (inputTypePacked && !outputTypeFloat)
            return false;

        // Invalid normalize. Normalize is only valid if output type is float
        if (this.normalize && !outputTypeFloat)
            return false;

        return true;
    };

    /**
     * @return {boolean}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.prototype.isBufferAligned = function() {
        var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10;

        // Buffer alignment, offset is a multiple of underlying data type size?
        if (this.storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            var dataTypeSize = glsDrawTests.DrawTestSpec.inputTypeSize(this.inputType);
            if (inputTypePacked)
                dataTypeSize = 4;

            if (this.offset % dataTypeSize != 0)
                return false;
        }

        return true;
    };

    /**
     * @return {boolean}
     */
    glsDrawTests.DrawTestSpec.AttributeSpec.prototype.isBufferStrideAligned = function() {
        var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10;

        // Buffer alignment, offset is a multiple of underlying data type size?
        if (this.storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) {
            var dataTypeSize = glsDrawTests.DrawTestSpec.inputTypeSize(this.inputType);
            if (inputTypePacked)
                dataTypeSize = 4;

            if (this.stride % dataTypeSize != 0)
                return false;
        }

        return true;
    };

    /**
     * @constructor
     * @extends {tcuTestCase.DeqpTest}
     * @param {glsDrawTests.DrawTestSpec} spec
     * @param {string} name
     * @param {string} desc
     */
    glsDrawTests.DrawTest = function(spec, name, desc) {
        tcuTestCase.DeqpTest.call(this, name, desc, spec);

        /** @type {WebGL2RenderingContext} */ this.m_renderCtx = gl;
        /** @type {tcuPixelFormat.PixelFormat} */ this.m_pixelformat = new tcuPixelFormat.PixelFormat(
            /** @type {number} */ (gl.getParameter(gl.RED_BITS)), /** @type {number} */ (gl.getParameter(gl.GREEN_BITS)),
            /** @type {number} */ (gl.getParameter(gl.BLUE_BITS)), /** @type {number} */ (gl.getParameter(gl.ALPHA_BITS))
        );

        /** @type {sglrReferenceContext.ReferenceContextBuffers} */ this.m_refBuffers = null;
        /** @type {sglrReferenceContext.ReferenceContext} */ this.m_refContext = null;
        /** @type {sglrGLContext.GLContext} */ this.m_glesContext = null;

        /** @type {glsDrawTests.AttributePack} */ this.m_glArrayPack = null;
        /** @type {glsDrawTests.AttributePack} */ this.m_rrArrayPack = null;

        /** @type {number} */ this.m_maxDiffRed = -1;
        /** @type {number} */ this.m_maxDiffGreen = -1;
        /** @type {number} */ this.m_maxDiffBlue = -1;

        /** @type {Array<glsDrawTests.DrawTestSpec>} */ this.m_specs = [];
        /** @type {Array<string>} */this.m_iteration_descriptions = [];
        /** @type {number} */ this.m_iteration = 0;

        if (spec)
            this.addIteration(spec);
    };

    glsDrawTests.DrawTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
    glsDrawTests.DrawTest.prototype.constructor = glsDrawTests.DrawTest;

    /**
     * @param {glsDrawTests.DrawTestSpec} spec
     * @param {string=} description
     */
    glsDrawTests.DrawTest.prototype.addIteration = function(spec, description) {
        // Validate spec
        /** @type {boolean} */ var validSpec = spec.valid();

        if (!validSpec)
            return;

        this.m_specs.push(spec);

        if (description)
            this.m_iteration_descriptions.push(description);
        else
            this.m_iteration_descriptions.push('');
    };

    /**
     * init
     */
    glsDrawTests.DrawTest.prototype.init = function() {
        var renderTargetWidth = Math.min(glsDrawTests.MAX_RENDER_TARGET_SIZE, gl.canvas.width);
        var renderTargetHeight = Math.min(glsDrawTests.MAX_RENDER_TARGET_SIZE, gl.canvas.height);
        /** @type {sglrReferenceContext.ReferenceContextLimits} */ var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
        /** @type {boolean} */ var useVao = true;

        this.m_glesContext = new sglrGLContext.GLContext(gl);

        assertMsgOptions(this.m_specs.length > 0, 'Specs is empty', false, true);

        this.m_refBuffers = new sglrReferenceContext.ReferenceContextBuffers(this.m_pixelformat, 0, 0, renderTargetWidth, renderTargetHeight);
        this.m_refContext = new sglrReferenceContext.ReferenceContext(limits, this.m_refBuffers.getColorbuffer(), this.m_refBuffers.getDepthbuffer(), this.m_refBuffers.getStencilbuffer());

        this.m_glArrayPack = new glsDrawTests.AttributePack(this.m_glesContext, [renderTargetWidth, renderTargetHeight], useVao, true);
        this.m_rrArrayPack = new glsDrawTests.AttributePack(this.m_refContext, [renderTargetWidth, renderTargetHeight], useVao, false);

        this.m_maxDiffRed = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.redBits)));
        this.m_maxDiffGreen = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.greenBits)));
        this.m_maxDiffBlue = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.blueBits)));
    };

    /**
     * @return {tcuTestCase.IterateResult}
     */
    glsDrawTests.DrawTest.prototype.iterate = function() {
        var specNdx = Math.floor(this.m_iteration / 2);
        var drawStep = (this.m_iteration % 2) == 0;
        var compareStep = (this.m_iteration % 2) == 1;
        /** @type {tcuTestCase.IterateResult} */ var iterateResult = (this.m_iteration + 1 == this.m_specs.length * 2) ? (tcuTestCase.IterateResult.STOP) : (tcuTestCase.IterateResult.CONTINUE);
        /** @type {glsDrawTests.DrawTestSpec} */ var spec = this.m_specs[specNdx];
        var updateProgram = (this.m_iteration == 0) || (drawStep && !glsDrawTests.checkSpecsShaderCompatible(this.m_specs[specNdx], this.m_specs[specNdx - 1])); // try to use the same shader in all iterations

        if (drawStep && this.m_specs.length != 1)
            debug('Iteration ' + specNdx + ' of ' + (this.m_specs.length - 1) + ': ' + this.m_iteration_descriptions[specNdx]);

        this.m_iteration++;

        if (drawStep) {
            /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(spec.drawMethod);
            /** @type {boolean} */ var indexed = methodInfo.indexed;
            /** @type {boolean} */ var instanced = methodInfo.instanced;
            /** @type {boolean} */ var ranged = methodInfo.ranged;
            /** @type {boolean} */ var hasFirst = methodInfo.first;

            /** @type {number} */ var primitiveElementCount = glsDrawTests.getElementCount(spec.primitive, spec.primitiveCount); // !< elements to be drawn
            /** @type {number} */ var indexMin = (ranged) ? (spec.indexMin) : (0);
            /** @type {number} */ var firstAddition = (hasFirst) ? (spec.first) : (0);
            /** @type {number} */ var elementCount = primitiveElementCount + indexMin + firstAddition; // !< elements in buffer (buffer should have at least primitiveElementCount ACCESSIBLE (index range, first) elements)
            /** @type {number} */ var maxElementIndex = primitiveElementCount + indexMin + firstAddition - 1;
            /** @type {number} */ var indexMax = Math.max(0, (ranged) ? (deMath.clamp(spec.indexMax, 0, maxElementIndex)) : (maxElementIndex));
            /** @type {number} */ var coordScale = this.getCoordScale(spec);
            /** @type {number} */ var colorScale = this.getColorScale(spec);

            /** @type {Array<number>} */ var nullAttribValue = [];

            // Log info
            bufferedLogToConsole(spec.getMultilineDesc());

            // Data
            this.m_glArrayPack.clearArrays();
            this.m_rrArrayPack.clearArrays();

            // indices
            /** @type {number} */ var seed;
            /** @type {number} */ var indexElementSize;
            /** @type {number} */ var indexArraySize;
            /** @type {goog.TypedArray} */ var indexArray;
            /** @type {goog.TypedArray} */ var indexPointer;

            /** @type {glsDrawTests.AttributeArray}*/ var glArray;
            /** @type {glsDrawTests.AttributeArray}*/ var rrArray;

            if (indexed) {
                seed = spec.hash();
                indexElementSize = glsDrawTests.DrawTestSpec.indexTypeSize(spec.indexType);
                indexArraySize = spec.indexPointerOffset + indexElementSize * elementCount;
                indexArray = glsDrawTests.RandomArrayGenerator.generateIndices(seed, elementCount, spec.indexType, spec.indexPointerOffset, indexMin, indexMax);
                indexPointer = indexArray.subarray(spec.indexPointerOffset);

                glArray = new glsDrawTests.AttributeArray(spec.indexStorage, this.m_glesContext);
                rrArray = new glsDrawTests.AttributeArray(spec.indexStorage, this.m_refContext);

                glArray.data(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY, indexArraySize, indexArray, glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW);
                rrArray.data(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY, indexArraySize, indexArray, glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW);

                indexArray = null;
            }

            // attributes
            for (var attribNdx = 0; attribNdx < spec.attribs.length; attribNdx++) {
                /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[attribNdx];
                var isPositionAttr = (attribNdx == 0) || (attribSpec.additionalPositionAttribute);

                if (attribSpec.useDefaultAttribute) {
                    seed = 10 * attribSpec.hash() + 100 * spec.hash() + attribNdx;
                    /** @type {Array<number>} */ var attribValue = glsDrawTests.RandomArrayGenerator.generateAttributeValue(seed, attribSpec.inputType);

                    // changed USER for BUFFER in JS version
                    this.m_glArrayPack.newArray(glsDrawTests.DrawTestSpec.Storage.BUFFER);
                    this.m_rrArrayPack.newArray(glsDrawTests.DrawTestSpec.Storage.BUFFER);

                    this.m_glArrayPack.getArray(attribNdx).setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr);
                    this.m_rrArrayPack.getArray(attribNdx).setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr);
                } else {
                    seed = attribSpec.hash() + 100 * spec.hash() + attribNdx;
                    /** @type {number} */ var elementSize = attribSpec.componentCount * glsDrawTests.DrawTestSpec.inputTypeSize(attribSpec.inputType);
                    /** @type {number} */ var stride = (attribSpec.stride == 0) ? (elementSize) : (attribSpec.stride);
                    /** @type {number} */ var evaluatedElementCount = (instanced && attribSpec.instanceDivisor > 0) ? (spec.instanceCount / attribSpec.instanceDivisor + 1) : (elementCount);
                    /** @type {number} */ var referencedElementCount = (ranged) ? (Math.max(evaluatedElementCount, spec.indexMax + 1)) : (evaluatedElementCount);
                    /** @type {number} */ var bufferSize = attribSpec.offset + stride * (referencedElementCount - 1) + elementSize;
                    /** @type {goog.TypedArray} */ var data = glsDrawTests.RandomArrayGenerator.createArray(
                        seed,
                        referencedElementCount,
                        attribSpec.componentCount,
                        attribSpec.offset,
                        stride,
                        attribSpec.inputType,
                        indexed ? 0 : spec.first,
                        spec.primitive,
                        indexed ? indexPointer : null,
                        indexElementSize
                    );

                    this.m_glArrayPack.newArray(attribSpec.storage);
                    this.m_rrArrayPack.newArray(attribSpec.storage);

                    this.m_glArrayPack.getArray(attribNdx).data(glsDrawTests.DrawTestSpec.Target.ARRAY, bufferSize, data, attribSpec.usage);
                    this.m_rrArrayPack.getArray(attribNdx).data(glsDrawTests.DrawTestSpec.Target.ARRAY, bufferSize, data, attribSpec.usage);

                    this.m_glArrayPack.getArray(attribNdx).setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr);
                    this.m_rrArrayPack.getArray(attribNdx).setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr);

                    data = null;
                }
            }

            // Shader program
            if (updateProgram) {
                this.m_glArrayPack.updateProgram();
                this.m_rrArrayPack.updateProgram();
            }

            /** @type {glsDrawTests.DrawTestSpec.CompatibilityTestType} */ var ctype;

            // Draw
            try {
                // indices
                if (indexed) {
                    this.m_glArrayPack.render(spec.primitive, spec.drawMethod, 0, primitiveElementCount, spec.indexType, spec.indexPointerOffset, spec.indexMin, spec.indexMax, spec.instanceCount, coordScale, colorScale, glArray);
                    this.m_rrArrayPack.render(spec.primitive, spec.drawMethod, 0, primitiveElementCount, spec.indexType, spec.indexPointerOffset, spec.indexMin, spec.indexMax, spec.instanceCount, coordScale, colorScale, rrArray);
                } else {
                    this.m_glArrayPack.render(spec.primitive, spec.drawMethod, spec.first, primitiveElementCount, null, 0, 0, 0, spec.instanceCount, coordScale, colorScale, null);
                    this.m_rrArrayPack.render(spec.primitive, spec.drawMethod, spec.first, primitiveElementCount, null, 0, 0, 0, spec.instanceCount, coordScale, colorScale, null);
                }
            } catch (err) {
                if (err instanceof wtu.GLErrorException) {
                    // GL Errors are ok if the mode is not properly aligned
                    ctype = spec.isCompatibilityTest();

                    bufferedLogToConsole('Got error: ' + err.message);

                    if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET)
                        checkMessage(false, 'Failed to draw with unaligned buffers.');
                    else if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE)
                        checkMessage(false, 'Failed to draw with unaligned stride.');
                    else
                        throw err;
                }
            }
        } else if (compareStep) {
            if (!this.compare(spec.primitive)) {
                ctype = spec.isCompatibilityTest();

                if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET)
                    checkMessage(false, 'Failed to draw with unaligned buffers.');
                else if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE)
                    checkMessage(false, 'Failed to draw with unaligned stride.');
                else
                    testFailedOptions('Image comparison failed.', false);
                return iterateResult;
            }
        } else {
            testFailedOptions('Image comparison failed.', false);
            return tcuTestCase.IterateResult.STOP;
        }

        if (iterateResult == tcuTestCase.IterateResult.STOP)
            testPassed('');

        return iterateResult;
    };

    /**
     * @enum {number} PrimitiveClass
     */
    glsDrawTests.PrimitiveClass = {
        POINT: 0,
        LINE: 1,
        TRIANGLE: 2
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitiveType
     * @return {glsDrawTests.PrimitiveClass}
     */
    glsDrawTests.getDrawPrimitiveClass = function(primitiveType) {
        switch (primitiveType) {
            case glsDrawTests.DrawTestSpec.Primitive.POINTS:
                return glsDrawTests.PrimitiveClass.POINT;

            case glsDrawTests.DrawTestSpec.Primitive.LINES:
            case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP:
            case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP:
                return glsDrawTests.PrimitiveClass.LINE;

            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES:
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN:
            case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP:
                return glsDrawTests.PrimitiveClass.TRIANGLE;

            default:
                throw new Error('Invalid primitive type');
        }
    };

    /**
     * @param {number} c1
     * @param {number} c2
     * @param {Array<number>} threshold
     * @return {boolean}
     */
    glsDrawTests.compareUintRGB8 = function(c1, c2, threshold) {
        return (Math.abs(((c1 >> 16) & 0xff) - ((c2 >> 16) & 0xff)) <= threshold[0] &&  // Red
                Math.abs(((c1 >> 8) & 0xff) - ((c2 >> 8) & 0xff)) <= threshold[1] &&    // Green
                Math.abs((c1 & 0xff) - (c2 & 0xff)) <= threshold[2]);                   // Blue
    };

    /**
     * @param {number} c1
     * @param {number} c2
     * @param {number} c3
     * @param {number} renderTargetDifference
     * @return {boolean}
     */
    glsDrawTests.isEdgeTripletComponent = function(c1, c2, c3, renderTargetDifference) {
        /** @type {number} */ var roundingDifference = 2 * renderTargetDifference; // src and dst pixels rounded to different directions
        /** @type {number} */ var d1 = c2 - c1;
        /** @type {number} */ var d2 = c3 - c2;
        /** @type {number} */ var rampDiff = Math.abs(d2 - d1);

        return rampDiff > roundingDifference;
    };

    /**
     * @param {tcuRGBA.RGBA} c1
     * @param {tcuRGBA.RGBA} c2
     * @param {tcuRGBA.RGBA} c3
     * @param {Array<number>} renderTargetThreshold
     * @return {boolean}
     */
    glsDrawTests.isEdgeTriplet = function(c1, c2, c3, renderTargetThreshold) {
        // black (background color) and non-black is always an edge
        /** @type {boolean} */ var b1 = c1 == 0x000000;
        /** @type {boolean} */ var b2 = c2 == 0x000000;
        /** @type {boolean} */ var b3 = c3 == 0x000000;

        // both pixels with coverage and pixels without coverage
        if ((b1 && b2 && b3) == false && (b1 || b2 || b3) == true)
            return true;
        // all black
        if (b1 && b2 && b3)
            return false;
        // all with coverage
        assertMsgOptions(!b1 && !b2 && !b3, 'All colors with coverage', false, true);

        // Color is always linearly interpolated => component values change nearly linearly
        // in any constant direction on triangle hull. (df/dx ~= C).

        // Edge detection (this function) is run against the reference image
        // => no dithering to worry about

        return glsDrawTests.isEdgeTripletComponent((c1 >> 16) && 0xff, (c2 >> 16) && 0xff, (c3 >> 16) && 0xff, renderTargetThreshold[0]) ||
            glsDrawTests.isEdgeTripletComponent((c1 >> 8) && 0xff, (c2 >> 8) && 0xff, (c3 >> 8) && 0xff, renderTargetThreshold[1]) ||
            glsDrawTests.isEdgeTripletComponent(c1 && 0xff, c2 && 0xff, c3 && 0xff, renderTargetThreshold[2]);
    };

    /**
     * @param {number} x
     * @param {number} y
     * @param {tcuSurface.Surface} ref
     * @param {Array<number>} renderTargetThreshold
     * @return {boolean}
     */
    glsDrawTests.pixelNearEdge = function(x, y, ref, renderTargetThreshold) {
        // should not be called for edge pixels
        assertMsgOptions(x >= 1 && x <= ref.getWidth() - 2, 'The pixel was on the edge', false, true);
        assertMsgOptions(y >= 1 && y <= ref.getHeight() - 2, 'The pixel was on the edge', false, true);

        // horizontal

        /** @type {number} */ var c1;
        /** @type {number} */ var c2;
        /** @type {number} */ var c3;

        for (var dy = -1; dy < 2; ++dy) {
            c1 = ref.getPixelUintRGB8(x - 1, y + dy);
            c2 = ref.getPixelUintRGB8(x, y + dy);
            c3 = ref.getPixelUintRGB8(x + 1, y + dy);
            if (glsDrawTests.isEdgeTriplet(c1, c2, c3, renderTargetThreshold))
                return true;
        }

        // vertical

        for (var dx = -1; dx < 2; ++dx) {
            c1 = ref.getPixelUintRGB8(x + dx, y - 1);
            c2 = ref.getPixelUintRGB8(x + dx, y);
            c3 = ref.getPixelUintRGB8(x + dx, y + 1);
            if (glsDrawTests.isEdgeTriplet(c1, c2, c3, renderTargetThreshold))
                return true;
        }

        return false;
    };

    /**
     * @param {number} c
     * @return {number}
     */
    glsDrawTests.getVisualizationGrayscaleColorUintRGB8 = function(c) {
        // make triangle coverage and error pixels obvious by converting coverage to grayscale
        if (c == 0x000000)
            return 0;
        else
            return 50 + Math.floor((((c >> 16) & 0xff) + ((c >> 8) & 0xff) + (c & 0xff)) / 8);
    };

    /**
     * @param {number} x
     * @param {number} y
     * @param {tcuSurface.Surface} target
     * @return {boolean}
     */
    glsDrawTests.pixelNearLineIntersection = function(x, y, target) {
        // should not be called for edge pixels
        assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true);
        assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true);

        var coveredPixels = 0;

        for (var dy = -1; dy < 2; dy++)
        for (var dx = -1; dx < 2; dx++) {
            var targetCoverage = target.getPixelUintRGB8(x + dx, y + dy);
            if (targetCoverage) {
                ++coveredPixels;

                // A single thin line cannot have more than 3 covered pixels in a 3x3 area
                if (coveredPixels >= 4)
                    return true;
            }
        }

        return false;
    };

    // search 3x3 are for matching color
    /**
     * @param {tcuSurface.Surface} target
     * @param {number} x
     * @param {number} y
     * @param {tcuRGBA.RGBA} color
     * @param {Array<number>} compareThreshold
     * @return {boolean}
     */
    glsDrawTests.pixelNeighborhoodContainsColor = function(target, x, y, color, compareThreshold) {
        // should not be called for edge pixels
        assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true);
        assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true);

        for (var dy = -1; dy < 2; dy++)
        for (var dx = -1; dx < 2; dx++) {
            if (glsDrawTests.compareUintRGB8(color, target.getPixelUintRGB8(x + dx, y + dy), compareThreshold))
                return true;
        }

        return false;
    };

    // search 3x3 are for matching coverage (coverage == (color != background color))
    /**
     * @param {tcuSurface.Surface} target
     * @param {number} x
     * @param {number} y
     * @param {boolean} coverage
     * @return {boolean}
     */
    glsDrawTests.pixelNeighborhoodContainsCoverage = function(target, x, y, coverage) {
        // should not be called for edge pixels
        assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true);
        assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true);

        for (var dy = -1; dy < 2; dy++)
        for (var dx = -1; dx < 2; dx++) {
            var targetCmpCoverage = target.getPixelUintRGB8(x + dx, y + dy) != 0x000000; // Pixel is not black
            if (targetCmpCoverage == coverage)
                return true;
        }

        return false;
    };

    /**
     * @param {string} imageSetName
     * @param {string} imageSetDesc
     * @param {tcuSurface.Surface} reference
     * @param {tcuSurface.Surface} result
     * @param {Array<number>} compareThreshold
     * @param {Array<number>} renderTargetThreshold
     * @param {number} maxAllowedInvalidPixels
     * @return {boolean}
     */
    glsDrawTests.edgeRelaxedImageCompare = function(imageSetName, imageSetDesc, reference, result, compareThreshold, renderTargetThreshold, maxAllowedInvalidPixels) {
        assertMsgOptions(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight(), 'Reference and result images have different dimensions', false, true);

        /** @type {Array<number>} */ var green = [0, 255, 0, 255];
        /** @type {Array<number>} */ var errorColor = [255, 0, 0, 255];
        /** @type {number} */ var width = reference.getWidth();
        /** @type {number} */ var height = reference.getHeight();
        /** @type {tcuSurface.Surface} */ var errorMask = new tcuSurface.Surface(width, height);
        /** @type {number} */ var numFailingPixels = 0;

        // clear errormask edges which would otherwise be transparent

        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, width, 1, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, height - 1, 0, width, 1, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, 1, height, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), width - 1, 0, 0, 1, height, 1).clear(green);

        // skip edge pixels since coverage on edge cannot be verified

        for (var y = 1; y < height - 1; ++y)
        for (var x = 1; x < width - 1; ++x) {
            /** @type {number} */ var refPixel = reference.getPixelUintRGB8(x, y);
            /** @type {number} */ var screenPixel = result.getPixelUintRGB8(x, y);
            /** @type {boolean} */ var isOkReferencePixel = glsDrawTests.pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold); // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.)
            /** @type {boolean} */ var isOkScreenPixel = glsDrawTests.pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold); // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.)

            if (isOkScreenPixel && isOkReferencePixel) {
                // pixel valid, write greenish pixels to make the result image easier to read
                /** @type {number} */ var grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel);
                errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y);
            } else if (!glsDrawTests.pixelNearEdge(x, y, reference, renderTargetThreshold)) {
                // non-edge pixel values must be within threshold of the reference values
                errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y);
                ++numFailingPixels;
            } else {
                // we are on/near an edge, verify only coverage (coverage == not background colored)
                /** @type {boolean} */ var referenceCoverage = refPixel != 0x000000; // Not black
                /** @type {boolean} */ var screenCoverage = screenPixel != 0x000000; // Not black
                /** @type {boolean} */ var isOkReferenceCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage); // Check reference pixel against screen pixel
                /** @type {boolean} */ var isOkScreenCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage); // Check screen pixels against reference pixel

                if (isOkScreenCoverage && isOkReferenceCoverage) {
                    // pixel valid, write greenish pixels to make the result image easier to read
                    var grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel);
                    errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y);
                } else {
                    // coverage does not match
                    errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y);
                    ++numFailingPixels;
                }
            }
        }

        bufferedLogToConsole(
            'Comparing images:</br>' +
            '<span> </span>allowed deviation in pixel positions = 1</br>' +
            '<span> </span>number of allowed invalid pixels = ' + maxAllowedInvalidPixels + '</br>' +
            '<span> </span>number of invalid pixels = ' + numFailingPixels
        );

        if (numFailingPixels > maxAllowedInvalidPixels) {
            debug('Image comparison failed. Color threshold = (' + compareThreshold[0] + ', ' + compareThreshold[1] + ', ' + compareThreshold[2] + ')');
            tcuImageCompare.displayImages(result.getAccess(), reference.getAccess(), errorMask.getAccess());

            return false;
        } else {
            return true;
        }
    };

    /**
     * @param {string} imageSetName
     * @param {string} imageSetDesc
     * @param {tcuSurface.Surface} reference
     * @param {tcuSurface.Surface} result
     * @param {Array<number>} compareThreshold
     * @param {number} maxAllowedInvalidPixels
     * @return {boolean}
     */
    glsDrawTests.intersectionRelaxedLineImageCompare = function(imageSetName, imageSetDesc, reference, result, compareThreshold, maxAllowedInvalidPixels) {
        assertMsgOptions(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight(), 'Reference and result images have different dimensions', false, true);

        /** @type {Array<number>} */ var green = [0, 255, 0, 255];
        /** @type {Array<number>} */ var errorColor = [255, 0, 0, 255];
        var width = reference.getWidth();
        var height = reference.getHeight();
        /** @type {tcuSurface.Surface} */ var errorMask = new tcuSurface.Surface(width, height);
        /** @type {number} */ var numFailingPixels = 0;

        // clear errormask edges which would otherwise be transparent

        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, width, 1, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, height - 1, 0, width, 1, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, 1, height, 1).clear(green);
        tcuTextureUtil.getSubregion(errorMask.getAccess(), width - 1, 0, 0, 1, height, 1).clear(green);

        // skip edge pixels since coverage on edge cannot be verified

        for (var y = 1; y < height - 1; ++y)
        for (var x = 1; x < width - 1; ++x) {
            /** @type {number} */ var refPixel = reference.getPixelUintRGB8(x, y);
            /** @type {number} */ var screenPixel = result.getPixelUintRGB8(x, y);
            /** @type {boolean} */ var isOkScreenPixel = glsDrawTests.pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold); // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.)
            /** @type {boolean} */ var isOkReferencePixel = glsDrawTests.pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold); // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.)

            /** @type {number} */ var grayscaleValue;

            if (isOkScreenPixel && isOkReferencePixel) {
                // pixel valid, write greenish pixels to make the result image easier to read
                grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel);
                errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y);
            } else if (!glsDrawTests.pixelNearLineIntersection(x, y, reference) &&
                     !glsDrawTests.pixelNearLineIntersection(x, y, result)) {
                // non-intersection pixel values must be within threshold of the reference values
                errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y);
                ++numFailingPixels;
            } else {
                // pixel is near a line intersection
                // we are on/near an edge, verify only coverage (coverage == not background colored)
                /** @type {boolean} */ var referenceCoverage = refPixel != 0x000000; // Not Black
                /** @type {boolean} */ var screenCoverage = screenPixel != 0x000000; // Not Black
                /** @type {boolean} */ var isOkScreenCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage); // Check screen pixels against reference pixel
                /** @type {boolean} */ var isOkReferenceCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage); // Check reference pixel against screen pixel

                if (isOkScreenCoverage && isOkReferenceCoverage) {
                    // pixel valid, write greenish pixels to make the result image easier to read
                    grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel);
                    errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y);
                } else {
                    // coverage does not match
                    errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y);
                    ++numFailingPixels;
                }
            }
        }

        bufferedLogToConsole(
            'Comparing images:</br>' +
            '<span> </span>allowed deviation in pixel positions = 1</br>' +
            '<span> </span>number of allowed invalid pixels = ' + maxAllowedInvalidPixels + '</br>' +
            '<span> </span>number of invalid pixels = ' + numFailingPixels
        );

        if (numFailingPixels > maxAllowedInvalidPixels) {
            debug('Image comparison failed. Color threshold = (' + compareThreshold[0] + ', ' + compareThreshold[1] + ', ' + compareThreshold[2] + ')');
            tcuImageCompare.displayImages(result.getAccess(), reference.getAccess(), errorMask.getAccess());

            return false;
        } else {
            return true;
        }
    };

    /**
     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitiveType
     * @return {boolean}
     */
    glsDrawTests.DrawTest.prototype.compare = function(primitiveType) {
        /** @type {tcuSurface.Surface} */ var ref = this.m_rrArrayPack.getSurface();
        /** @type {tcuSurface.Surface} */ var screen = this.m_glArrayPack.getSurface();

        if (/** @type {number} */ (gl.getParameter(gl.SAMPLES)) > 1) {
            // \todo [mika] Improve compare when using multisampling
            bufferedLogToConsole('Warning: Comparision of result from multisample render targets are not as strict as without multisampling. Might produce false positives!');
            return tcuImageCompare.fuzzyCompare('Compare Results', 'Compare Results', ref.getAccess(), screen.getAccess(), 0.3, tcuImageCompare.CompareLogMode.RESULT);
        } else {
            /** @type {glsDrawTests.PrimitiveClass} */ var primitiveClass = glsDrawTests.getDrawPrimitiveClass(primitiveType);

            switch (primitiveClass) {
                case glsDrawTests.PrimitiveClass.POINT: {
                    // Point are extremely unlikely to have overlapping regions, don't allow any no extra / missing pixels
                    /**@type {number} */ var maxAllowedInvalidPixelsWithPoints = 0;
                    return tcuImageCompare.intThresholdPositionDeviationErrorThresholdCompare(
                        'CompareResult',
                        'Result of rendering',
                        ref.getAccess(),
                        screen.getAccess(),
                        [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue, 256],
                        [1, 1, 0], //!< 3x3 search kernel
                        true, //!< relax comparison on the image boundary
                        maxAllowedInvalidPixelsWithPoints //!< error threshold
                    );
                }

                case glsDrawTests.PrimitiveClass.LINE: {
                    // Lines can potentially have a large number of overlapping pixels. Pixel comparison may potentially produce
                    // false negatives in such pixels if for example the pixel in question is overdrawn by another line in the
                    // reference image but not in the resultin image. Relax comparison near line intersection points (areas) and
                    // compare only coverage, not color, in such pixels
                    /**@type {number} */ var maxAllowedInvalidPixelsWithLines = 15; // line are allowed to have a few bad pixels
                    return glsDrawTests.intersectionRelaxedLineImageCompare(
                        'CompareResult',
                        'Result of rendering',
                        ref,
                        screen,
                        [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue],
                        maxAllowedInvalidPixelsWithLines
                    );
                }

                case glsDrawTests.PrimitiveClass.TRIANGLE: {
                    // Triangles are likely to partially or fully overlap. Pixel difference comparison is fragile in pixels
                    // where there could be potential overlapping since the pixels might be covered by one triangle in the
                    // reference image and by the other in the result image. Relax comparsion near primitive edges and
                    // compare only coverage, not color, in such pixels.
                    /** @type {number} */ var maxAllowedInvalidPixelsWithTriangles = 10;

                    /* TODO: Implement
                    var renderTargetThreshold = //TODO: get color threshold from the pixel format --> m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold().toIVec().xyz();
                    */

                    /** @type {Array<number>} */ var renderTargetThreshold = [3, 3, 3, 3];

                    return glsDrawTests.edgeRelaxedImageCompare(
                        'CompareResult',
                        'Result of rendering',
                        ref,
                        screen,
                        [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue],
                        renderTargetThreshold,
                        maxAllowedInvalidPixelsWithTriangles
                    );
                }

                default:
                    throw new Error('Invalid primitive class');
            }
        }
    };

    /**
     * @param {glsDrawTests.DrawTestSpec} spec
     * @return {number}
     */
    glsDrawTests.DrawTest.prototype.getCoordScale = function(spec) {
        var maxValue = 1.0;

        for (var arrayNdx = 0; arrayNdx < spec.attribs.length; arrayNdx++) {
            /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[arrayNdx];
            /** @type {boolean} */ var isPositionAttr = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute);
            /** @type {number} */ var attrMaxValue = 0;

            if (!isPositionAttr)
                continue;

            if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10) {
                if (attribSpec.normalize)
                    attrMaxValue += 1.0;
                else
                    attrMaxValue += 1024.0;
            } else if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10) {
                if (attribSpec.normalize)
                    attrMaxValue += 1.0;
                else
                    attrMaxValue += 512.0;
            } else {
                var max = glsDrawTests.GLValue.getMaxValue(attribSpec.inputType).getValue();

                attrMaxValue += (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType)) ? (1.0) : (max * 1.1);
            }

            if (attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4 ||
                attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4 ||
                attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4)
                    attrMaxValue *= 2;

            maxValue += attrMaxValue;
        }

        return 1.0 / maxValue;
    };

    /**
     * @param {glsDrawTests.DrawTestSpec} spec
     * @return {number}
     */
    glsDrawTests.DrawTest.prototype.getColorScale = function(spec) {
        var colorScale = 1.0;

        for (var arrayNdx = 1; arrayNdx < spec.attribs.length; arrayNdx++) {
            /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[arrayNdx];
            /** @type {boolean} */ var isPositionAttr = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute);

            if (isPositionAttr)
                continue;

            if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10) {
                if (!attribSpec.normalize)
                    colorScale *= 1.0 / 1024.0;
            } else if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10) {
                if (!attribSpec.normalize)
                    colorScale *= 1.0 / 512.0;
            } else {
                var max = glsDrawTests.GLValue.getMaxValue(attribSpec.inputType).toFloat();

                colorScale *= (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType) ? 1.0 : (1.0 / max));
                if (attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4 ||
                    attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4 ||
                    attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4)
                    colorScale *= (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType) ? 1.0 : 1.0 / max);
            }
        }

        return colorScale;
    };
});