tor-browser

es3fShaderOperatorTests.js (157630B)

---

/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

'use strict';
goog.provide('functional.gles3.es3fShaderOperatorTests');
goog.require('framework.common.tcuTestCase');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.delibs.debase.deMath');
goog.require('modules.shared.glsShaderRenderCase');
goog.require('framework.common.tcuMatrix');

goog.scope(function() {
var es3fShaderOperatorTests = functional.gles3.es3fShaderOperatorTests;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var deMath = framework.delibs.debase.deMath;
var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
var tcuMatrix = framework.common.tcuMatrix;

/** @const */ es3fShaderOperatorTests.MAX_INPUTS = 3;

let canvasWH = 256;
if (tcuTestCase.isQuickMode()) {
   canvasWH = 32;
}

es3fShaderOperatorTests.stringJoin = function(elems, delim) {
   var result = '';
   for (var i = 0; i < elems.length; i++)
       result += (i > 0 ? delim : '') + elems[i];
   return result;
};

es3fShaderOperatorTests.twoValuedVec4 = function(first, second, firstMask) {
   var elems = [];
   for (var i = 0; i < 4; i++)
       elems[i] = firstMask[i] ? first : second;

   return 'vec4(' + es3fShaderOperatorTests.stringJoin(elems, ', ') + ')';
};

var setParentClass = function(child, parent) {
   child.prototype = Object.create(parent.prototype);
   child.prototype.constructor = child;
};

var negate = function(x) {
   return -x;
};

var addOne = function(x) {
   return x + 1;
};

var subOne = function(x) {
   return x - 1;
};

/**
* @param {number} a
* @param {number} b
*/
var add = function(a, b) {
   return a + b;
};

/**
* @param {number} a
* @param {number} b
*/
var sub = function(a, b) {
   return a - b;
};

/**
* @param {number} a
* @param {number} b
*/
var mul = function(a, b) {
   return a * b;
};

/**
* @param {number} a
* @param {number} b
*/
var div = function(a, b) {
   return a / b;
};

/**
* @param {number} a
* @param {number} b
* @return {number}
*/
var lessThan = function(a, b) {
   return a < b ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var lessThanVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] < b[i];
   return res
};

/**
* @param {number} a
* @param {number} b
* @return {number}
*/
var lessThanEqual = function(a, b) {
   return a <= b ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var lessThanEqualVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] <= b[i];
   return res;
};

/**
* @param {number} a
* @param {number} b
*/
var greaterThan = function(a, b) {
   return a > b ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var greaterThanVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] > b[i];
   return res;
};

/**
* @param {number} a
* @param {number} b
*/
var greaterThanEqual = function(a, b) {
   return a >= b ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var greaterThanEqualVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] >= b[i];
   return res;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {number}
*/
var allEqual = function(a, b) {
   return deMath.equal(a, b) ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var allEqualVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] == b[i];
   return res;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {number}
*/
var anyNotEqual = function(a, b) {
   return !deMath.equal(a, b) ? 1 : 0;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var anyNotEqualVec = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = a[i] != b[i];
   return res;
};

/**
* @param {Array<number>} a
* @return {Array<number>}
*/
var boolNotVec = function(a) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = !a[i];
   return res;
}

/**
* @param {Array<number>} a
* @return {boolean}
*/
var boolAny = function(a) {
   for (var i = 0; i < a.length; i++)
       if (a[i] == true)
           return true;
   return false;
}

/**
* @param {Array<number>} a
* @return {boolean}
*/
var boolAll = function(a) {
   for (var i = 0; i < a.length; i++)
       if (a[i] == false)
           return false;
   return true;
}

/**
* @param {number} a
* @param {number} b
*/
var logicalAnd = function(a, b) {
   return a && b ? 1 : 0;
};

/**
* @param {number} a
* @param {number} b
*/
var logicalOr = function(a, b) {
   return a || b ? 1 : 0;
};

/**
* @param {number} a
* @param {number} b
*/
var logicalXor = function(a, b) {
   return a != b ? 1 : 0;
};

/**
* @param {number} a
*/
var exp2 = function(a) {
   return deFloatExp2(a);
};

/**
* @param {number} a
*/
var inverseSqrt = function(a) {
   return deFloatRsq(a);
};

/**
* @param {Array<number>} a
* @param {number} b
* @return {Array<number>}
*/
var minVecScalar = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = Math.min(a[i], b);
   return res;
};

/**
* @param {Array<number>} a
* @param {number} b
* @return {Array<number>}
*/
var maxVecScalar = function(a, b) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = Math.max(a[i], b);
   return res;
};

/**
* @param {number} a
* @param {number} b
* @param {number} c
* @return {number}
*/
var mix = function(a, b, c) {
   return a * (1.0 - c) + b * c;
};
/**
* @param {Array<number>} a
* @param {Array<number>} b
* @param {number} c
* @return {Array<number>}
*/
var mixVecVecScalar = function(a, b, c) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = mix(a[i], b[i], c);
   return res;
};

/**
* @param {Array<number>} a
* @param {number} b
* @param {number} c
* @return {Array<number>}
*/
var clampVecScalarScalar = function(a, b, c) {
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = deMath.clamp(a[i], b, c);
   return res;
};

/**
* @param {number} a
* @param {number} b
* @return {number}
*/
var step = function(a, b) {
   return b < a ? 0.0 : 1.0;
};

/**
* @param {number} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var stepScalarVec = function(a, b) {
   var res = [];
   for (var i = 0; i < b.length; i++)
       res[i] = step(a, b[i]);
   return res;
};

/**
* @param {number} a
* @param {number} b
* @param {number} c
* @return {number}
*/
var smoothStep = function(a, b, c) {
   if (c <= a) return 0.0;
   if (c >= b) return 1.0;
   var t = deMath.clamp((c - a) / (b - a), 0.0, 1.0);
   return t * t * (3.0 - 2.0 * t);
};

/**
* @param {number} a
* @param {number} b
* @param {Array<number>} c
* @return {Array<number>}
*/
var smoothStepScalarScalarVec = function(a, b, c) {
   var res = [];
   for (var i = 0; i < c.length; i++)
       res[i] = smoothStep(a, b, c[i]);
   return res;
};

/**
* @param {number} a
* @return {number}
*/
var roundToEven = function(a) {
   var q = deMath.deFloatFrac(a);
   var r = a - q;

   if (q > 0.5)
       r += 1.0;
   else if (q == 0.5 && r % 2 != 0)
       r += 1.0;

   return r;
};

/**
* @param {number} a
* @return {number}
*/
var fract = function(a) {
   return a - Math.floor(a);
};

/**
* @param {number} a
* @return {number}
*/
var radians = function(a) {
   return deFloatRadians(a);
}

/**
* @param {number} a
* @return {number}
*/
var degrees = function(a) {
   return deFloatDegrees(a);
}

/**
* @param {number} a
* @param {Array<number>} b
*/
var addScalarVec = function(a, b) {
   return deMath.addScalar(b, a);
};

/**
* @param {number} a
* @param {Array<number>} b
*/
var subScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(a - b[i]);
   return dst;
};

/**
* @param {number} a
* @param {Array<number>} b
*/
var mulScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(a * b[i]);
   return dst;
};

/**
* @param {number} a
* @param {Array<number>} b
*/
var divScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(a / b[i]);
   return dst;
};

/**
* @param {number} a
* @param {Array<number>} b
*/
var modScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(a % b[i]);
   return dst;
};

var bitwiseAndScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(deMath.binaryOp(a, b[i], deMath.BinaryOp.AND));
   return dst;
};

var bitwiseOrScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(deMath.binaryOp(a, b[i], deMath.BinaryOp.OR));
   return dst;
};

var bitwiseXorScalarVec = function(a, b) {
   var dst = [];
   for (var i = 0; i < b.length; i++)
       dst.push(deMath.binaryOp(a, b[i], deMath.BinaryOp.XOR));
   return dst;
};

/**
* @param {Array<number>} a
* @return {number}
*/
var length = function(a) {
   var squareSum = 0;
   for (var i = 0; i < a.length; i++)
       squareSum += a[i] * a[i];
   return Math.sqrt(squareSum);
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {number}
*/
var distance = function(a, b) {
   var res = deMath.subtract(a, b)
   return length(res);
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {number}
*/
var dot = function(a, b) {
   var res = deMath.multiply(a, b);
   var sum = 0;
   for (var i = 0; i < res.length; i++)
       sum += res[i];
   return sum;
};

/**
* @param {Array<number>} a
* @return {Array<number>}
*/
var normalize = function(a) {
   var ooLen = 1 / length(a);
   var res = [];
   for (var i = 0; i < a.length; i++)
       res[i] = ooLen * a[i];
   return res;
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @param {Array<number>} c
* @return {Array<number>}
*/
var faceforward = function(a, b, c) {
   return dot(c, b) < 0 ? a : deMath.scale(a, -1);
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var reflect = function(a, b) {
   return deMath.subtract(a, deMath.scale(deMath.scale(b, dot(b, a)), 2));
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @param {number} c
* @return {Array<number>}
*/
var refract = function(a, b, c) {
   var cosAngle = dot(b, a);
   var k = 1 - c * c * (1 - cosAngle * cosAngle);
   if (k < 0) {
       var res = new Array(a.length);
       return res.fill(0)
   } else
       return deMath.subtract(deMath.scale(a, c), deMath.scale(b, c * cosAngle + Math.sqrt(k)));
};

/**
* @param {Array<number>} a
* @param {Array<number>} b
* @return {Array<number>}
*/
var cross = function(a, b) {
   if (a.length != 3 || b.length != 3)
       throw new Error('Arrays must have the size of 3');
   return [
       a[1] * b[2] - b[1] * a[2],
       a[2] * b[0] - b[2] * a[0],
       a[0] * b[1] - b[0] * a[1]];
};

var nop = function(v) {
   return v;
};

var selection = function(cond, a, b) {
   return cond ? a : b;
};

var boolNot = function(a) {
   return !a;
};

var bitwiseNot = function(a) {
   return ~a;
};

/**
* @param {number} x
* @return {number}
*/
var deFloatRadians = function(x) {
   return x * (Math.PI / 180.0);
};

/**
* @param {number} x
* @return {number}
*/
var deFloatDegrees = function(x) {
   return x * (180.0 / Math.PI);
};

/**
* @param {number} x
* @return {number}
*/
var deFloatExp2 = function(x) {
   return Math.exp(x * Math.LN2);
};

/**
* @param {number} x
* @return {number}
*/
var deFloatLog2 = function(x) {
   return Math.log(x) * Math.LOG2E;
};

/**
* @param {number} x
* @return {number}
*/
var deFloatRsq = function(x) {
   var s = Math.sqrt(x);
   return s == 0.0 ? 0.0 : (1.0 / s);
};

/**
* @constructor
* @param {boolean} low
* @param {boolean} medium
* @param {boolean} high
*/
es3fShaderOperatorTests.Precision = function(low, medium, high) {
   this.low = low;
   this.medium = medium;
   this.high = high;
};

/** @const */ es3fShaderOperatorTests.Precision.Low = new es3fShaderOperatorTests.Precision(true, false, false);
/** @const */ es3fShaderOperatorTests.Precision.Medium = new es3fShaderOperatorTests.Precision(false, true, false);
/** @const */ es3fShaderOperatorTests.Precision.High = new es3fShaderOperatorTests.Precision(false, false, true);
/** @const */ es3fShaderOperatorTests.Precision.LowMedium = new es3fShaderOperatorTests.Precision(true, true, false);
/** @const */ es3fShaderOperatorTests.Precision.MediumHigh = new es3fShaderOperatorTests.Precision(false, true, true);
/** @const */ es3fShaderOperatorTests.Precision.All = new es3fShaderOperatorTests.Precision(true, true, true);
/** @const */ es3fShaderOperatorTests.Precision.None = new es3fShaderOperatorTests.Precision(false, false, false);

/**
* @enum
*/
es3fShaderOperatorTests.ValueType = {
   NONE: 0,
   FLOAT: (1 << 0), // float scalar
   FLOAT_VEC: (1 << 1), // float vector
   FLOAT_GENTYPE: (1 << 2), // float scalar/vector
   VEC3: (1 << 3), // vec3 only
   MATRIX: (1 << 4), // matrix
   BOOL: (1 << 5), // boolean scalar
   BOOL_VEC: (1 << 6), // boolean vector
   BOOL_GENTYPE: (1 << 7), // boolean scalar/vector
   INT: (1 << 8), // int scalar
   INT_VEC: (1 << 9), // int vector
   INT_GENTYPE: (1 << 10), // int scalar/vector
   UINT: (1 << 11), // uint scalar
   UINT_VEC: (1 << 12), // uint vector
   UINT_GENTYPE: (1 << 13) // uint scalar/vector
};

/**
* @param {es3fShaderOperatorTests.ValueType} type
* @return {boolean}
*/
es3fShaderOperatorTests.isBoolType = function(type) {
   return (type & (es3fShaderOperatorTests.ValueType.BOOL | es3fShaderOperatorTests.ValueType.BOOL_VEC | es3fShaderOperatorTests.ValueType.BOOL_GENTYPE)) != 0;
};

/**
* @param {es3fShaderOperatorTests.ValueType} type
* @return {boolean}
*/
es3fShaderOperatorTests.isIntType = function(type) {
   return (type & (es3fShaderOperatorTests.ValueType.INT | es3fShaderOperatorTests.ValueType.INT_VEC | es3fShaderOperatorTests.ValueType.INT_GENTYPE)) != 0;
};

/**
* @param {es3fShaderOperatorTests.ValueType} type
* @return {boolean}
*/
es3fShaderOperatorTests.isUintType = function(type) {
   return (type & (es3fShaderOperatorTests.ValueType.UINT | es3fShaderOperatorTests.ValueType.UINT_VEC | es3fShaderOperatorTests.ValueType.UINT_GENTYPE)) != 0;
};

/**
* @param {es3fShaderOperatorTests.ValueType} type
* @return {boolean}
*/
es3fShaderOperatorTests.isScalarType = function(type) {
   return type == es3fShaderOperatorTests.ValueType.FLOAT || type == es3fShaderOperatorTests.ValueType.BOOL || type == es3fShaderOperatorTests.ValueType.INT || type == es3fShaderOperatorTests.ValueType.UINT;
};

/**
* @param {es3fShaderOperatorTests.ValueType} type
* @return {boolean}
*/
es3fShaderOperatorTests.isFloatType = function(type) {
   return (type & (es3fShaderOperatorTests.ValueType.FLOAT | es3fShaderOperatorTests.ValueType.FLOAT_VEC | es3fShaderOperatorTests.ValueType.FLOAT_GENTYPE)) != 0;
};

/**
* @param {gluShaderProgram.shaderType} shaderType
* @param {gluShaderUtil.precision} uintPrecision
* @return {number}
*/
es3fShaderOperatorTests.getGLSLUintMaxAsFloat = function(shaderType, uintPrecision) {
   switch (uintPrecision) {
       case gluShaderUtil.precision.PRECISION_LOWP:
           var intPrecisionGL = gl.LOW_INT;
           break;
       case gluShaderUtil.precision.PRECISION_MEDIUMP:
           var intPrecisionGL = gl.MEDIUM_INT;
           break;
       case gluShaderUtil.precision.PRECISION_HIGHP:
           var intPrecisionGL = gl.HIGH_INT;
           break;
       default:
           assertMsgOptions(false, 'Invalid shader type', false, false);
           var intPrecisionGL = 0;
   }

   switch (shaderType) {
       case gluShaderProgram.shaderType.VERTEX:
           var shaderTypeGL = gl.VERTEX_SHADER;
           break;
       case gluShaderProgram.shaderType.FRAGMENT:
           var shaderTypeGL = gl.FRAGMENT_SHADER;
           break;
       default:
           assertMsgOptions(false, 'Invalid shader type', false, false);
           var shaderTypeGL = 0;
   }

   /** @type {WebGLShaderPrecisionFormat } */ var sPrecision = gl.getShaderPrecisionFormat(shaderTypeGL, intPrecisionGL);
   assertMsgOptions(gl.getError() === gl.NO_ERROR, 'glGetShaderPrecisionFormat failed', false, true);

   if (!deMath.deInBounds32(sPrecision.rangeMin, 8, 32))
       throw new Error('Out of range');

   var numBitsInType = sPrecision.rangeMin + 1;
   return Math.pow(2, numBitsInType) - 1;
};

/**
* @enum
*/
es3fShaderOperatorTests.OperationType = {
   FUNCTION: 0,
   OPERATOR: 1,
   SIDE_EFFECT_OPERATOR: 2 // Test the side-effect (as opposed to the result) of a side-effect operator.
};

/**
* swizzling indices for assigning the tested function output to the correct color channel
*/
es3fShaderOperatorTests.outIndices = [];
es3fShaderOperatorTests.outIndices[1] = [0];
es3fShaderOperatorTests.outIndices[2] = [1, 2];
es3fShaderOperatorTests.outIndices[3] = [0, 1, 2];
es3fShaderOperatorTests.outIndices[4] = [0, 1, 2, 3];

var convert = function(input, dataType) {
   switch (dataType) {
       case gluShaderUtil.DataType.INT:
           if (input instanceof Array) {
               var ret = [];
               for (var i = 0; i < input.length; i++)
                   ret[i] = deMath.intCast(input[i]);
               return ret;
           }
           return deMath.intCast(input);
       case gluShaderUtil.DataType.UINT:
           if (input instanceof Array) {
               var ret = [];
               for (var i = 0; i < input.length; i++)
                   ret[i] = deMath.uintCast(input[i]);
               return ret;
           }
           return deMath.uintCast(input);
       case gluShaderUtil.DataType.BOOL:
           if (input instanceof Array) {
               var ret = [];
               for (var i = 0; i < input.length; i++)
                   ret[i] = input[i] > 0 ? 1 : 0;
               return ret;
           }
           return input > 0 ? 1 : 0;

   }
   return input;
};

/**
* Generate unary functions which have the same input and return type
* @param {function(number): number} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.unaryGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input) {
       if (input instanceof Array) {
           var len = input.length;
           var indices = es3fShaderOperatorTests.outIndices[len];
           for (var i = 0; i < input.length; i++)
                output[indices[i]] = convert(func(convert(input[i], dataTypeIn)), dataTypeOut);
       } else
           output[0] = convert(func(convert(input, dataTypeIn)), dataTypeOut);
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, c.in_[0][2]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0])); };
   return functions;
};

/**
* Generate unary functions which have the same input and return type
* @param {function(Array<number>): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.unaryArrayFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input) {
       var len = input.length;
       var indices = es3fShaderOperatorTests.outIndices[len];
       var value = convert(func(convert(input, dataTypeIn)), dataTypeOut);
       for (var i = 0; i < input.length; i++)
            output[indices[i]] = value[i];
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, [c.in_[0][2]]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0])); };
   return functions;
};

/**
* Generate unary functions which always have scalar return type
* @param {function(Array<number>): number} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.unaryScalarGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input) {
       output[0] = convert(func(convert(input, dataTypeIn)), dataTypeOut);
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, [c.in_[0][2]]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0])); };
   return functions;
};

/**
* Generate unary functions which always have bolean return type
* @param {function(Array<number>): boolean} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.unaryBooleanGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input) {
       output[0] = convert(func(convert(input, dataTypeIn)), dataTypeOut);
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, [c.in_[0][2] > 0.0]); };
   functions.vec2 = function(c) { run(c.color, func, greaterThanVec(deMath.swizzle(c.in_[0], [3, 1]), [0, 0])); };
   functions.vec3 = function(c) { run(c.color, func, greaterThanVec(deMath.swizzle(c.in_[0], [2, 0, 1]), [0, 0, 0])); };
   functions.vec4 = function(c) { run(c.color, func, greaterThanVec(deMath.swizzle(c.in_[0], [1, 2, 3, 0]), [0, 0, 0, 0])); };
   return functions;
};

/**
* Generate binary functions which have the same input and return type
* @param {function(number, number): number} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.binaryGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input1, input2) {
       if (input1 instanceof Array) {
           var len = input1.length;
           var indices = es3fShaderOperatorTests.outIndices[len];
           for (var i = 0; i < input1.length; i++)
                output[indices[i]] = convert(func(convert(input1[i], dataTypeIn), convert(input2[i], dataTypeIn)), dataTypeOut);
       } else {
           var value = convert(func(convert(input1, dataTypeIn), convert(input2, dataTypeIn)), dataTypeOut);
           output[0] = value;
       }
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, c.in_[0][2], c.in_[1][0]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0])); };
   return functions;
};

/**
* Generate binary functions which have the same input and return type
* @param {function(number, number, number): number} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.ternaryGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input1, input2, input3) {
       if (input1 instanceof Array) {
           var len = input1.length;
           var indices = es3fShaderOperatorTests.outIndices[len];
           for (var i = 0; i < input1.length; i++)
                output[indices[i]] = convert(func(convert(input1[i], dataTypeIn), convert(input2[i], dataTypeIn), convert(input3[i], dataTypeIn)), dataTypeOut);
       } else {
           var value = convert(func(convert(input1, dataTypeIn), convert(input2, dataTypeIn), convert(input3, dataTypeIn)), dataTypeOut);
           output[0] = value;
       }
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, c.in_[0][2], c.in_[1][0], c.in_[2][1]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0]), deMath.swizzle(c.in_[2], [2, 1])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0]), deMath.swizzle(c.in_[2], [3, 1, 2])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0]), deMath.swizzle(c.in_[2], [0, 3, 2, 1])); };
   return functions;
};

/**
* Generate binary functions which have the same input and return type
* @param {function(Array<number>, Array<number>): number} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.binaryScalarGenTypeFuncs = function(func, dataTypeOut, dataTypeIn) {
   var run = function(output, func, input1, input2) {
       var value = convert(func(convert(input1, dataTypeIn), convert(input2, dataTypeIn)), dataTypeOut);
       output[0] = value;
   };

   var functions = {};
   functions.scalar = function(c) { run(c.color, func, [c.in_[0][2]], [c.in_[1][0]]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0])); };
   return functions;
};

/**
* Generate (cond ? a : b) functions
* @param {gluShaderUtil.DataType} dataType
* Returns an array of functions, indexed by datatype size
*/
es3fShaderOperatorTests.selectionFuncs = function(dataType) {
   var run = function(output, input0, input1, input2) {
       var value = selection(input0, input1, input2);
       value = convert(value, dataType);
       if (value instanceof Array) {
           var len = value.length;
           var indices = es3fShaderOperatorTests.outIndices[len];
           for (var i = 0; i < len; i++)
               output[indices[i]] = value[i];
       } else
           output[0] = value;
   };

   var functions = [];
   functions[1] = function(c) { run(c.color, c.in_[0][2] > 0, c.in_[1][0], c.in_[2][1]); };
   functions[2] = function(c) { run(c.color, c.in_[0][2] > 0, deMath.swizzle(c.in_[1], [1, 0]), deMath.swizzle(c.in_[2], [2, 1])); };
   functions[3] = function(c) { run(c.color, c.in_[0][2] > 0, deMath.swizzle(c.in_[1], [1, 2, 0]), deMath.swizzle(c.in_[2], [3, 1, 2])); };
   functions[4] = function(c) { run(c.color, c.in_[0][2] > 0, deMath.swizzle(c.in_[1], [3, 2, 1, 0]), deMath.swizzle(c.in_[2], [0, 3, 2, 1])); };
   return functions;
};

var cp = function(dst, src) {
   var len = src.length;
   var indices = es3fShaderOperatorTests.outIndices[len];
   for (var i = 0; i < len; i++)
       dst[indices[i]] = src[i];
};

/**
* Generate binary functions of form: vec = func(scalar, vec)
* @param {function(number, Array<number>): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.binaryScalarVecFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(number, Array<number>): Array<number>} func
    * @param {number} input1
    * @param {Array<number>} input2
    */
   var run = function(output, func, input1, input2) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var value = func(in1, in2);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, c.in_[0][2], deMath.swizzle(c.in_[1], [1, 0])); };
   functions.vec3 = function(c) { run(c.color, func, c.in_[0][2], deMath.swizzle(c.in_[1], [1, 2, 0])); };
   functions.vec4 = function(c) { run(c.color, func, c.in_[0][2], deMath.swizzle(c.in_[1], [3, 2, 1, 0])); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(vec, scalar)
* @param {function(Array<number>, number): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.binaryVecScalarFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(Array<number>, number): Array<number>} func
    * @param {Array<number>} input1
    * @param {number} input2
    */
   var run = function(output, func, input1, input2) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var value = func(in1, in2);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), c.in_[1][0]); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), c.in_[1][0]); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), c.in_[1][0]); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(vec, vec, scalar)
* @param {function(Array<number>, Array<number>, number): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.ternaryVecVecScalarFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(Array<number>, Array<number>, number): Array<number>} func
    * @param {Array<number>} input1
    * @param {Array<number>} input2
    * @param {number} input3
    */
   var run = function(output, func, input1, input2, input3) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var in3 = convert(input3, dataTypeIn);
       var value = func(in1, in2, in3);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.scalar = function(c) { run(c.color, func, [c.in_[0][2]], [c.in_[1][0]], c.in_[2][1]); };
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0]), c.in_[2][1]); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0]), c.in_[2][1]); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0]), c.in_[2][1]); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(vec, scalar, scalar)
* @param {function(Array<number>, number, number): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.ternaryVecScalarScalarFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(Array<number>, number, number): Array<number>} func
    * @param {Array<number>} input1
    * @param {number} input2
    * @param {number} input3
    */
   var run = function(output, func, input1, input2, input3) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var in3 = convert(input3, dataTypeIn);
       var value = func(in1, in2, in3);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), c.in_[1][0], c.in_[2][1]); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), c.in_[1][0], c.in_[2][1]); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), c.in_[1][0], c.in_[2][1]); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(scalar, scalar, vec)
* @param {function(number, number, Array<number>): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.ternaryScalarScalarVecFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(number, number, Array<number>): Array<number>} func
    * @param {number} input1
    * @param {number} input2
    * @param {Array<number>} input3
    */
   var run = function(output, func, input1, input2, input3) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var in3 = convert(input3, dataTypeIn);
       var value = func(in1, in2, in3);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, c.in_[0][2], c.in_[1][0], deMath.swizzle(c.in_[2], [2, 1])); };
   functions.vec3 = function(c) { run(c.color, func, c.in_[0][2], c.in_[1][0], deMath.swizzle(c.in_[2], [3, 1, 2])); };
   functions.vec4 = function(c) { run(c.color, func, c.in_[0][2], c.in_[1][0], deMath.swizzle(c.in_[2], [0, 3, 2, 1])); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(vec, vec, vec)
* @param {function(Array<number>, Array<number>, Array<number>): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.ternaryVecVecVecFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(Array<number>, Array<number>, Array<number>): Array<number>} func
    * @param {Array<number>} input1
    * @param {Array<number>} input2
    * @param {Array<number>} input3
    */
   var run = function(output, func, input1, input2, input3) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var in3 = convert(input3, dataTypeIn);
       var value = func(in1, in2, in3);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0]), deMath.swizzle(c.in_[2], [2, 1])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0]), deMath.swizzle(c.in_[2], [3, 1, 2])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0]), deMath.swizzle(c.in_[2], [0, 3, 2, 1])); };
   return functions;
};

/**
* Generate binary functions of form: vec = func(vec, vec)
* @param {function(Array<number>, Array<number>): Array<number>} func
* @param {gluShaderUtil.DataType=} dataTypeIn
* @param {gluShaderUtil.DataType=} dataTypeOut
*/
es3fShaderOperatorTests.binaryVecVecFuncs = function(func, dataTypeOut, dataTypeIn) {
   /**
    * @param {function(Array<number>, Array<number>): Array<number>} func
    * @param {Array<number>} input1
    * @param {Array<number>} input2
    */
   var run = function(output, func, input1, input2) {
       var in1 = convert(input1, dataTypeIn);
       var in2 = convert(input2, dataTypeIn);
       var value = func(in1, in2);
       value = convert(value, dataTypeOut);
       cp(output, value);
   };
   var functions = {};
   functions.vec2 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [3, 1]), deMath.swizzle(c.in_[1], [1, 0])); };
   functions.vec3 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [2, 0, 1]), deMath.swizzle(c.in_[1], [1, 2, 0])); };
   functions.vec4 = function(c) { run(c.color, func, deMath.swizzle(c.in_[0], [1, 2, 3, 0]), deMath.swizzle(c.in_[1], [3, 2, 1, 0])); };
   return functions;
};

/**
* @constructor
* @param {es3fShaderOperatorTests.ValueType} valueType
* @param {es3fShaderOperatorTests.FloatScalar} rangeMin
* @param {es3fShaderOperatorTests.FloatScalar} rangeMax
*/
es3fShaderOperatorTests.Value = function(valueType, rangeMin, rangeMax) {
   this.valueType = valueType;
   this.rangeMin = rangeMin;
   this.rangeMax = rangeMax;
};

/**
* @enum
*/
es3fShaderOperatorTests.Symbol = {
   SYMBOL_LOWP_UINT_MAX: 0,
   SYMBOL_MEDIUMP_UINT_MAX: 1,

   SYMBOL_LOWP_UINT_MAX_RECIPROCAL: 2,
   SYMBOL_MEDIUMP_UINT_MAX_RECIPROCAL: 3,

   SYMBOL_ONE_MINUS_UINT32MAX_DIV_LOWP_UINT_MAX: 4,
   SYMBOL_ONE_MINUS_UINT32MAX_DIV_MEDIUMP_UINT_MAX: 5

};

/**
* @constructor
* @param {number|es3fShaderOperatorTests.Symbol} value
* @param {boolean=} isSymbol
*/
es3fShaderOperatorTests.FloatScalar = function(value, isSymbol) {
   if (isSymbol)
       this.symbol = /** @type {es3fShaderOperatorTests.Symbol} */ (value);
   else
       this.constant = /** @type {number} */ (value);
};

/**
* @param {gluShaderProgram.shaderType} shaderType
* @return {number}
*/
es3fShaderOperatorTests.FloatScalar.prototype.getValue = function(shaderType) {
   if (this.constant !== undefined)
       return this.constant;
   else
       switch (this.symbol) {
           case es3fShaderOperatorTests.Symbol.SYMBOL_LOWP_UINT_MAX:
               return es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_LOWP);
           case es3fShaderOperatorTests.Symbol.SYMBOL_MEDIUMP_UINT_MAX:
               return es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_MEDIUMP);

           case es3fShaderOperatorTests.Symbol.SYMBOL_LOWP_UINT_MAX_RECIPROCAL:
               return 1.0 / es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_LOWP);
           case es3fShaderOperatorTests.Symbol.SYMBOL_MEDIUMP_UINT_MAX_RECIPROCAL:
               return 1.0 / es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_MEDIUMP);

           case es3fShaderOperatorTests.Symbol.SYMBOL_ONE_MINUS_UINT32MAX_DIV_LOWP_UINT_MAX:
               return 1.0 - 0xFFFFFFFF / es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_LOWP);
           case es3fShaderOperatorTests.Symbol.SYMBOL_ONE_MINUS_UINT32MAX_DIV_MEDIUMP_UINT_MAX:
               return 1.0 - 0xFFFFFFFF / es3fShaderOperatorTests.getGLSLUintMaxAsFloat(shaderType, gluShaderUtil.precision.PRECISION_MEDIUMP);

           default:
               assertMsgOptions(false, 'Invalid shader type', false, false);
               return 0.0;
       }
};

/**
* @constructor
* @param {gluShaderUtil.DataType=} type
* @param {es3fShaderOperatorTests.FloatScalar=} rangeMin
* @param {es3fShaderOperatorTests.FloatScalar=} rangeMax
*/
es3fShaderOperatorTests.ShaderValue = function(type, rangeMin, rangeMax) {
   this.type = type || gluShaderUtil.DataType.INVALID;
   this.rangeMin = rangeMin || new es3fShaderOperatorTests.FloatScalar(0);
   this.rangeMax = rangeMax || new es3fShaderOperatorTests.FloatScalar(0);
};

/**
* @constructor
*/
es3fShaderOperatorTests.ShaderDataSpec = function() {
   /** @type {es3fShaderOperatorTests.FloatScalar} */ this.resultScale = new es3fShaderOperatorTests.FloatScalar(1);
   /** @type {es3fShaderOperatorTests.FloatScalar} */ this.resultBias = new es3fShaderOperatorTests.FloatScalar(0);
   /** @type {es3fShaderOperatorTests.FloatScalar} */ this.referenceScale = new es3fShaderOperatorTests.FloatScalar(1);
   /** @type {es3fShaderOperatorTests.FloatScalar} */ this.referenceBias = new es3fShaderOperatorTests.FloatScalar(0);
   /** @type {es3fShaderOperatorTests.Precision} */ this.precision = es3fShaderOperatorTests.Precision.None;
   /** @type {gluShaderUtil.DataType} */ this.output;
   /** @type {number} */ this.numInputs = 0;
   /** @type {Array<es3fShaderOperatorTests.ShaderValue>}*/ this.inputs = [];
   for (var i = 0; i < es3fShaderOperatorTests.MAX_INPUTS; i++)
       this.inputs[i] = new es3fShaderOperatorTests.ShaderValue();
};

/**
* @constructor
* @struct
* @param {string} caseName
* @param {string} shaderFuncName
* @param {es3fShaderOperatorTests.ValueType} outValue
* @param {Array<es3fShaderOperatorTests.Value>} inputs
* @param {es3fShaderOperatorTests.FloatScalar} resultScale
* @param {es3fShaderOperatorTests.FloatScalar} resultBias
* @param {es3fShaderOperatorTests.FloatScalar} referenceScale
* @param {es3fShaderOperatorTests.FloatScalar} referenceBias
* @param {gluShaderUtil.precision} precision
* @param {*} functions
* @param {es3fShaderOperatorTests.OperationType=} type
* @param {boolean=} isUnaryPrefix
*/
es3fShaderOperatorTests.BuiltinFuncInfo = function(caseName, shaderFuncName, outValue, inputs, resultScale, resultBias, referenceScale, referenceBias, precision, functions, type, isUnaryPrefix) {
   this.caseName = caseName;
   this.shaderFuncName = shaderFuncName;
   this.outValue = outValue;
   this.inputs = inputs;
   this.resultScale = resultScale;
   this.resultBias = resultBias;
   this.referenceScale = referenceScale;
   this.referenceBias = referenceBias;
   this.precision = precision;
   this.evalFunctions = functions;
   this.type = type || es3fShaderOperatorTests.OperationType.FUNCTION;
   this.isUnaryPrefix = isUnaryPrefix === undefined ? true : isUnaryPrefix;
};

es3fShaderOperatorTests.builtinOperInfo = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                  shaderFuncName,
                                                  outValue,
                                                  inputs,
                                                  scale,
                                                  bias,
                                                  scale,
                                                  bias,
                                                  precision,
                                                  functions,
                                                  es3fShaderOperatorTests.OperationType.OPERATOR);
};

es3fShaderOperatorTests.builtinFunctionInfo = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                  shaderFuncName,
                                                  outValue,
                                                  inputs,
                                                  scale,
                                                  bias,
                                                  scale,
                                                  bias,
                                                  precision,
                                                  functions,
                                                  es3fShaderOperatorTests.OperationType.FUNCTION);
};

es3fShaderOperatorTests.builtinSideEffOperInfo = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                  shaderFuncName,
                                                  outValue,
                                                  inputs,
                                                  scale,
                                                  bias,
                                                  scale,
                                                  bias,
                                                  precision,
                                                  functions,
                                                  es3fShaderOperatorTests.OperationType.SIDE_EFFECT_OPERATOR);
};

es3fShaderOperatorTests.builtinOperInfoSeparateRefScaleBias = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions, referenceScale, referenceBias) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                   shaderFuncName,
                                                   outValue,
                                                   inputs,
                                                   scale,
                                                   bias,
                                                   referenceScale,
                                                   referenceBias,
                                                   precision,
                                                   functions,
                                                   es3fShaderOperatorTests.OperationType.OPERATOR);
};

es3fShaderOperatorTests.BuiltinPostSideEffOperInfo = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                   shaderFuncName,
                                                   outValue,
                                                   inputs,
                                                   scale,
                                                   bias,
                                                   scale,
                                                   bias,
                                                   precision,
                                                   functions,
                                                   es3fShaderOperatorTests.OperationType.SIDE_EFFECT_OPERATOR,
                                                   false);
};
es3fShaderOperatorTests.BuiltinPostOperInfo = function(caseName, shaderFuncName, outValue, inputs, scale, bias, precision, functions) {
   return new es3fShaderOperatorTests.BuiltinFuncInfo(caseName,
                                                   shaderFuncName,
                                                   outValue,
                                                   inputs,
                                                   scale,
                                                   bias,
                                                   scale,
                                                   bias,
                                                   precision,
                                                   functions,
                                                   es3fShaderOperatorTests.OperationType.OPERATOR,
                                                   false);
};

/**
* @constructor
* @param {string} name
* @param {string} description
*/
es3fShaderOperatorTests.BuiltinFuncGroup = function(name, description) {
   this.name = name;
   this.description = description;
   this.funcInfos = [];
};

es3fShaderOperatorTests.BuiltinFuncGroup.prototype.push = function(a) { this.funcInfos.push(a); };

var s_inSwizzles = [

   ['z', 'wy', 'zxy', 'yzwx'],
   ['x', 'yx', 'yzx', 'wzyx'],
   ['y', 'zy', 'wyz', 'xwzy']
];

var s_outSwizzles = ['x', 'yz', 'xyz', 'xyzw'];

var s_outSwizzleChannelMasks = [
   [true, false, false, false],
   [false, true, true, false],
   [true, true, true, false],
   [true, true, true, true]
];

/**
* @constructor
* @extends {glsShaderRenderCase.ShaderEvaluator}
* @param {gluShaderProgram.shaderType} shaderType
* @param {glsShaderRenderCase.ShaderEvalFunc} evalFunc
* @param {es3fShaderOperatorTests.FloatScalar} scale
* @param {es3fShaderOperatorTests.FloatScalar} bias
* @param {number} resultScalarSize
*/
es3fShaderOperatorTests.OperatorShaderEvaluator = function(shaderType, evalFunc, scale, bias, resultScalarSize) {
   glsShaderRenderCase.ShaderEvaluator.call(this, evalFunc);
   this.m_shaderType = shaderType;
   this.m_scale = scale;
   this.m_bias = bias;
   this.m_resultScalarSize = resultScalarSize;
   this.m_areScaleAndBiasEvaluated = false;
};

setParentClass(es3fShaderOperatorTests.OperatorShaderEvaluator, glsShaderRenderCase.ShaderEvaluator);

es3fShaderOperatorTests.OperatorShaderEvaluator.prototype.evaluate = function(ctx) {
   this.m_evalFunc(ctx);

   if (!this.m_areScaleAndBiasEvaluated) {
       this.m_evaluatedScale = this.m_scale.getValue(this.m_shaderType);
       this.m_evaluatedBias = this.m_bias.getValue(this.m_shaderType);
       this.m_areScaleAndBiasEvaluated = true;
   }

   for (var i = 0; i < 4; i++)
       if (s_outSwizzleChannelMasks[this.m_resultScalarSize - 1][i])
           ctx.color[i] = ctx.color[i] * this.m_evaluatedScale + this.m_evaluatedBias;
};

/**
* @constructor
* @extends {glsShaderRenderCase.ShaderRenderCase}
* @param {string} caseName
* @param {string} description
* @param {boolean} isVertexCase
* @param {glsShaderRenderCase.ShaderEvalFunc} evalFunc
* @param {string} shaderOp
* @param {es3fShaderOperatorTests.ShaderDataSpec} spec
*/
es3fShaderOperatorTests.ShaderOperatorCase = function(caseName, description, isVertexCase, evalFunc, shaderOp, spec) {
   glsShaderRenderCase.ShaderRenderCase.call(this, caseName, description, isVertexCase, evalFunc);
   this.m_spec = spec;
   this.m_shaderOp = shaderOp;
   var shaderType = isVertexCase ? gluShaderProgram.shaderType.VERTEX : gluShaderProgram.shaderType.FRAGMENT;
   this.m_evaluator = new es3fShaderOperatorTests.OperatorShaderEvaluator(shaderType,
                                                                          evalFunc,
                                                                          spec.referenceScale,
                                                                          spec.referenceBias,
                                                                          gluShaderUtil.getDataTypeScalarSize(spec.output));
};

setParentClass(es3fShaderOperatorTests.ShaderOperatorCase, glsShaderRenderCase.ShaderRenderCase);

es3fShaderOperatorTests.ShaderOperatorCase.prototype.setupShaderData = function() {
   var shaderType = this.m_isVertexCase ? gluShaderProgram.shaderType.VERTEX : gluShaderProgram.shaderType.FRAGMENT;
   var precision = this.m_spec.precision !== undefined ? gluShaderUtil.getPrecisionName(this.m_spec.precision) : null;
   var inputPrecision = [];
   var sources = [];
   sources[0] = ''; //vertex
   sources[1] = ''; //fragment
   var vtx = 0;
   var frag = 1;
   var op = this.m_isVertexCase ? vtx : frag;

   sources[vtx] += '#version 300 es\n';
   sources[frag] += '#version 300 es\n';

   // Compute precision for inputs.
   for (var i = 0; i < this.m_spec.numInputs; i++) {
       var isBoolVal = gluShaderUtil.isDataTypeBoolOrBVec(this.m_spec.inputs[i].type);
       var isIntVal = gluShaderUtil.isDataTypeIntOrIVec(this.m_spec.inputs[i].type);
       var isUintVal = gluShaderUtil.isDataTypeUintOrUVec(this.m_spec.inputs[i].type);
       // \note Mediump interpolators are used for booleans, and highp for integers.
       var prec = isBoolVal ? gluShaderUtil.precision.PRECISION_MEDIUMP :
                               isIntVal || isUintVal ? gluShaderUtil.precision.PRECISION_HIGHP :
                               this.m_spec.precision;
       inputPrecision[i] = gluShaderUtil.getPrecisionName(prec);
   }

   // Attributes.
   sources[vtx] += 'in highp vec4 a_position;\n';
   for (var i = 0; i < this.m_spec.numInputs; i++)
       sources[vtx] += 'in ' + inputPrecision[i] + ' vec4 a_in' + i + ';\n';

   // Color output.
   sources[frag] += 'layout(location = 0) out mediump vec4 o_color;\n';

   if (this.m_isVertexCase) {
       sources[vtx] += 'out mediump vec4 v_color;\n';
       sources[frag] += 'in mediump vec4 v_color;\n';
   } else{
       for (var i = 0; i < this.m_spec.numInputs; i++) {
           sources[vtx] += 'out ' + inputPrecision[i] + ' vec4 v_in' + i + ';\n';
           sources[frag] += 'in ' + inputPrecision[i] + ' vec4 v_in' + i + ';\n';
       }
   }

   sources[vtx] += '\n';
   sources[vtx] += 'void main()\n';
   sources[vtx] += '{\n';
   sources[vtx] += ' gl_Position = a_position;\n';

   sources[frag] += '\n';
   sources[frag] += 'void main()\n';
   sources[frag] += '{\n';

   // Expression inputs.
   var prefix = this.m_isVertexCase ? 'a_' : 'v_';
   for (var i = 0; i < this.m_spec.numInputs; i++) {
       var inType = this.m_spec.inputs[i].type;
       var inSize = gluShaderUtil.getDataTypeScalarSize(inType);
       var isInt = gluShaderUtil.isDataTypeIntOrIVec(inType);
       var isUint = gluShaderUtil.isDataTypeUintOrUVec(inType);
       var isBool = gluShaderUtil.isDataTypeBoolOrBVec(inType);
       var typeName = gluShaderUtil.getDataTypeName(inType);
       var swizzle = s_inSwizzles[i][inSize - 1];

       sources[op] += '\t';
       if (precision && !isBool) sources[op] += precision + ' ';

       sources[op] += typeName + ' in' + i + ' = ';

       if (isBool) {
           if (inSize == 1) sources[op] += '(';
           else sources[op] += 'greaterThan(';
       } else if (isInt || isUint)
           sources[op] += typeName + '(';

       sources[op] += prefix + 'in' + i + '.' + swizzle;

       if (isBool) {
           if (inSize == 1) sources[op] += ' > 0.0)';
           else sources[op] += ', vec' + inSize + '(0.0))';
       } else if (isInt || isUint)
           sources[op] += ')';

       sources[op] += ';\n';
   }

   // Result variable.
   var outTypeName = gluShaderUtil.getDataTypeName(this.m_spec.output);
   var isBoolOut = gluShaderUtil.isDataTypeBoolOrBVec(this.m_spec.output);

   sources[op] += '\t';
   if (precision && !isBoolOut) sources[op] += precision + ' ';
   sources[op] += outTypeName + ' res = ' + outTypeName + '(0.0);\n\n';


   // Expression.
   sources[op] += '\t' + this.m_shaderOp + '\n\n';

   // Convert to color.
   var isResFloatVec = gluShaderUtil.isDataTypeFloatOrVec(this.m_spec.output);
   var outScalarSize = gluShaderUtil.getDataTypeScalarSize(this.m_spec.output);

   sources[op] += '\thighp vec4 color = vec4(0.0, 0.0, 0.0, 1.0);\n';
   sources[op] += '\tcolor.' + s_outSwizzles[outScalarSize - 1] + ' = ';

   if (!isResFloatVec && outScalarSize == 1)
       sources[op] += 'float(res)';
   else if (!isResFloatVec)
       sources[op] += 'vec' + outScalarSize + '(res)';
   else
       sources[op] += 'res';

   sources[op] += ';\n';

   // Scale & bias.
   var resultScale = this.m_spec.resultScale.getValue(shaderType);
   var resultBias = this.m_spec.resultBias.getValue(shaderType);
   if ((resultScale != 1.0) || (resultBias != 0.0)) {
       sources[op] += '\tcolor = color';
       if (resultScale != 1.0) sources[op] += ' * ' + es3fShaderOperatorTests.twoValuedVec4(resultScale.toString(10), '1.0', s_outSwizzleChannelMasks[outScalarSize - 1]);
       if (resultBias != 0.0) sources[op] += ' + ' + es3fShaderOperatorTests.twoValuedVec4(resultBias.toString(10), '0.0', s_outSwizzleChannelMasks[outScalarSize - 1]);
       sources[op] += ';\n';
   }

   // ..
   if (this.m_isVertexCase) {
       sources[vtx] += ' v_color = color;\n';
       sources[frag] += ' o_color = v_color;\n';
   } else{
       for (var i = 0; i < this.m_spec.numInputs; i++)
       sources[vtx] += ' v_in' + i + ' = a_in' + i + ';\n';
       sources[frag] += ' o_color = color;\n';
   }

   sources[vtx] += '}\n';
   sources[frag] += '}\n';

   this.m_vertShaderSource = sources[vtx];
   this.m_fragShaderSource = sources[frag];

   // Setup the user attributes.
   this.m_userAttribTransforms = [];
   for (var inputNdx = 0; inputNdx < this.m_spec.numInputs; inputNdx++) {
       var v = this.m_spec.inputs[inputNdx];

       var rangeMin = v.rangeMin.getValue(shaderType);
       var rangeMax = v.rangeMax.getValue(shaderType);
       var scale = rangeMax - rangeMin;
       var minBias = rangeMin;
       var maxBias = rangeMax;
       var attribMatrix = new tcuMatrix.Matrix(4, 4);

       for (var rowNdx = 0; rowNdx < 4; rowNdx++) {
           var row;

           switch ((rowNdx + inputNdx) % 4) {
               case 0: row = [scale, 0.0, 0.0, minBias]; break;
               case 1: row = [0.0, scale, 0.0, minBias]; break;
               case 2: row = [-scale, 0.0, 0.0, maxBias]; break;
               case 3: row = [0.0, -scale, 0.0, maxBias]; break;
               default: throw new Error('Invalid row index');
           }

           attribMatrix.setRow(rowNdx, row);
       }

       this.m_userAttribTransforms[inputNdx] = attribMatrix;
   }

};

// Reference functions for specific sequence operations for the sequence operator tests.
/**
* Reference for expression "in0, in2 + in1, in1 + in0"
* @param {Array<number>} in0 Vec4
* @param {Array<number>} in1 Vec4
* @param {Array<number>} in2 Vec4
* @return {Array<number>} Vec4
*/
es3fShaderOperatorTests.sequenceNoSideEffCase0 = function(in0, in1, in2) {
   return deMath.add(in1, in0);
};

/**
* Reference for expression "in0, in2 + in1, in1 + in0"
* @param {number} in0 float
* @param {number} in1 deUint32
* @param {number} in2 float
* @return {number} deUint32
*/
es3fShaderOperatorTests.sequenceNoSideEffCase1 = function(in0, in1, in2) {
   in1 = convert(in1, gluShaderUtil.DataType.UINT);
   return convert(in1 + in1, gluShaderUtil.DataType.UINT);
};

/**
* Reference for expression "in0 && in1, in0, ivec2(vec2(in0) + in2)"
* @param {boolean} in0
* @param {boolean} in1
* @param {Array<number>} in2 Vec2
* @return {Array<number>} IVec2
*/
es3fShaderOperatorTests.sequenceNoSideEffCase2 = function(in0, in1, in2) {
   in0 = convert(in0, gluShaderUtil.DataType.BOOL);
   return convert([in0 + in2[0], in0 + in2[1]], gluShaderUtil.DataType.INT);
};

/**
* Reference for expression "in0 + vec4(in1), in2, in1"
* @param {Array<number>} in0 Vec4
* @param {Array<number>} in1 IVec4
* @param {Array<boolean>} in2 BVec4
* @return {Array<number>} IVec4
*/
es3fShaderOperatorTests.sequenceNoSideEffCase3 = function(in0, in1, in2) {
   return convert(in1, gluShaderUtil.DataType.INT);
};

/**
* Reference for expression "in0++, in1 = in0 + in2, in2 = in1"
* @param {Array<number>} in0 Vec4
* @param {Array<number>} in1 Vec4
* @param {Array<number>} in2 Vec4
* @return {Array<number>} Vec4
*/
es3fShaderOperatorTests.sequenceSideEffCase0 = function(in0, in1, in2) {
   return deMath.add(deMath.add(in0, [1.0, 1.0, 1.0, 1.0]), in2);
};

/**
* Reference for expression "in1++, in0 = float(in1), in1 = uint(in0 + in2)"
* @param {number} in0 float
* @param {number} in1 deUint32
* @param {number} in2 float
* @return {number} deUint32
*/
es3fShaderOperatorTests.sequenceSideEffCase1 = function(in0, in1, in2) {
   in1 = convert(in1, gluShaderUtil.DataType.UINT);
   return convert(in1 + 1.0 + in2, gluShaderUtil.DataType.UINT);
};

/**
* Reference for expression "in1 = in0, in2++, in2 = in2 + vec2(in1), ivec2(in2)"
* @param {boolean} in0
* @param {boolean} in1
* @param {Array<number>} in2 Vec2
* @return {Array<number>} IVec2
*/
es3fShaderOperatorTests.sequenceSideEffCase2 = function(in0, in1, in2) {
   in0 = convert(in0, gluShaderUtil.DataType.BOOL);
   return convert(deMath.add(deMath.add(in2, [1.0, 1.0]), [in0, in0]), gluShaderUtil.DataType.INT);
};

/**
* Reference for expression "in0 = in0 + vec4(in2), in1 = in1 + ivec4(in0), in1++"
* @param {Array<number>} in0 Vec4
* @param {Array<number>} in1 IVec4
* @param {Array<boolean>} in2 BVec4
* @return {Array<number>} IVec4
*/
es3fShaderOperatorTests.sequenceSideEffCase3 = function(in0, in1, in2) {
   in1 = convert(in1, gluShaderUtil.DataType.INT);
   in2 = convert(in2, gluShaderUtil.DataType.BOOL);
   in0 = deMath.add(in0, in2);
   in1 = deMath.add(in1, convert(in0, gluShaderUtil.DataType.INT));
   return in1;
};

// ShaderEvalFunc-type wrappers for the above functions.

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceNoSideEffCase0 = function(ctx) {
   ctx.color = es3fShaderOperatorTests.sequenceNoSideEffCase0(
       deMath.swizzle(ctx.in_[0], [1, 2, 3, 0]),
       deMath.swizzle(ctx.in_[1], [3, 2, 1, 0]),
       deMath.swizzle(ctx.in_[2], [0, 3, 2, 1])
   );
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceNoSideEffCase1 = function(ctx) {
   ctx.color[0] = es3fShaderOperatorTests.sequenceNoSideEffCase1(
       ctx.in_[0][2],
       ctx.in_[1][0],
       ctx.in_[2][1]
   );
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceNoSideEffCase2 = function(ctx) {
   /** @type {Array<number>} */ var result = es3fShaderOperatorTests.sequenceNoSideEffCase2(
       ctx.in_[0][2] > 0.0,
       ctx.in_[1][0] > 0.0,
       deMath.swizzle(ctx.in_[2], [2, 1])
   );
   ctx.color[1] = result[0];
   ctx.color[2] = result[1];
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceNoSideEffCase3 = function(ctx) {
   ctx.color = es3fShaderOperatorTests.sequenceNoSideEffCase3(
       deMath.swizzle(ctx.in_[0], [1, 2, 3, 0]),
       deMath.swizzle(ctx.in_[1], [3, 2, 1, 0]),
       deMath.greaterThan(deMath.swizzle(ctx.in_[2], [0, 3, 2, 1]), [0.0, 0.0, 0.0, 0.0])
   );
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceSideEffCase0 = function(ctx) {
   ctx.color = es3fShaderOperatorTests.sequenceSideEffCase0(
       deMath.swizzle(ctx.in_[0], [1, 2, 3, 0]),
       deMath.swizzle(ctx.in_[1], [3, 2, 1, 0]),
       deMath.swizzle(ctx.in_[2], [0, 3, 2, 1])
   );
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceSideEffCase1 = function(ctx) {
   ctx.color[0] = es3fShaderOperatorTests.sequenceSideEffCase1(
       ctx.in_[0][2],
       ctx.in_[1][0],
       ctx.in_[2][1]
   );
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceSideEffCase2 = function(ctx) {
   /** @type {Array<number>} */ var result = es3fShaderOperatorTests.sequenceSideEffCase2(
       ctx.in_[0][2] > 0.0,
       ctx.in_[1][0] > 0.0,
       deMath.swizzle(ctx.in_[2], [2, 1])
   );
   ctx.color[1] = result[0];
   ctx.color[2] = result[1];
};

/** @param {glsShaderRenderCase.ShaderEvalContext} ctx */
es3fShaderOperatorTests.evalSequenceSideEffCase3 = function(ctx) {
   ctx.color = es3fShaderOperatorTests.sequenceSideEffCase3(
       deMath.swizzle(ctx.in_[0], [1, 2, 3, 0]),
       deMath.swizzle(ctx.in_[1], [3, 2, 1, 0]),
       deMath.greaterThan(deMath.swizzle(ctx.in_[2], [0, 3, 2, 1]), [0.0, 0.0, 0.0, 0.0])
   );
};

/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderOperatorTests.ShaderOperatorTests = function() {
   tcuTestCase.DeqpTest.call(this, 'shaderop', 'Shader operators tests');
};

setParentClass(es3fShaderOperatorTests.ShaderOperatorTests, tcuTestCase.DeqpTest);

es3fShaderOperatorTests.ShaderOperatorTests.prototype.init = function() {
   var op = es3fShaderOperatorTests.builtinOperInfo;
   var side = es3fShaderOperatorTests.builtinSideEffOperInfo;
   var separate = es3fShaderOperatorTests.builtinOperInfoSeparateRefScaleBias;
   var postSide = es3fShaderOperatorTests.BuiltinPostSideEffOperInfo;
   var postOp = es3fShaderOperatorTests.BuiltinPostOperInfo;
   var all = es3fShaderOperatorTests.Precision.All;
   var highp = es3fShaderOperatorTests.Precision.High;
   var mediump = es3fShaderOperatorTests.Precision.Medium;
   var mediumhighp = es3fShaderOperatorTests.Precision.MediumHigh;
   var lowp = es3fShaderOperatorTests.Precision.Low;
   var na = es3fShaderOperatorTests.Precision.None;
   var GT = es3fShaderOperatorTests.ValueType.FLOAT_GENTYPE;
   var UGT = es3fShaderOperatorTests.ValueType.UINT_GENTYPE;
   var IGT = es3fShaderOperatorTests.ValueType.INT_GENTYPE;
   var BGT = es3fShaderOperatorTests.ValueType.BOOL_GENTYPE;
   var F = es3fShaderOperatorTests.ValueType.FLOAT;
   var I = es3fShaderOperatorTests.ValueType.INT;
   var U = es3fShaderOperatorTests.ValueType.UINT;
   var BV = es3fShaderOperatorTests.ValueType.BOOL_VEC;
   var FV = es3fShaderOperatorTests.ValueType.FLOAT_VEC;
   var IV = es3fShaderOperatorTests.ValueType.INT_VEC;
   var UV = es3fShaderOperatorTests.ValueType.UINT_VEC;
   var B = es3fShaderOperatorTests.ValueType.BOOL;
   var V3 = es3fShaderOperatorTests.ValueType.VEC3;
   var lUMax = es3fShaderOperatorTests.Symbol.SYMBOL_LOWP_UINT_MAX;
   var mUMax = es3fShaderOperatorTests.Symbol.SYMBOL_MEDIUMP_UINT_MAX;
   var lUMaxR = es3fShaderOperatorTests.Symbol.SYMBOL_LOWP_UINT_MAX_RECIPROCAL;
   var mUMaxR = es3fShaderOperatorTests.Symbol.SYMBOL_MEDIUMP_UINT_MAX_RECIPROCAL;
   var f = function(value) {
       return new es3fShaderOperatorTests.FloatScalar(value);
   };
   var s = function(value) {
       return new es3fShaderOperatorTests.FloatScalar(value, true);
   };
   var v = function(type, a, b) {
       return new es3fShaderOperatorTests.Value(type, f(a), f(b));
   };
   var v2 = function(type, a, b) {
       return new es3fShaderOperatorTests.Value(type, f(a), s(b));
   };
   var funcInfoGroups = [];
   var unary = new es3fShaderOperatorTests.BuiltinFuncGroup('unary_operator', 'Unary operator tests');
   funcInfoGroups.push(unary);

   unary.push(op('plus', '+', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop)));
   unary.push(op('plus', '+', IGT, [v(IGT, -5.0, 5.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(op('plus', '+', UGT, [v(UGT, 0.0, 2e2)], f(5e-3), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(op('minus', '-', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(negate)));
   unary.push(op('minus', '-', IGT, [v(IGT, -5.0, 5.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(negate, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(separate('minus', '-', UGT, [v2(UGT, 0.0, lUMax)], s(lUMaxR), f(0.0), lowp,
       es3fShaderOperatorTests.unaryGenTypeFuncs(negate, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT), s(lUMaxR),
       s(es3fShaderOperatorTests.Symbol.SYMBOL_ONE_MINUS_UINT32MAX_DIV_LOWP_UINT_MAX)));
   unary.push(separate('minus', '-', UGT, [v2(UGT, 0.0, mUMax)], s(mUMaxR), f(0.0), mediump,
       es3fShaderOperatorTests.unaryGenTypeFuncs(negate, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT), s(mUMaxR),
       s(es3fShaderOperatorTests.Symbol.SYMBOL_ONE_MINUS_UINT32MAX_DIV_MEDIUMP_UINT_MAX)));
   unary.push(op('minus', '-', UGT, [v(UGT, 0.0, 4e9)], f(2e-10), f(0.0), highp,
       es3fShaderOperatorTests.unaryGenTypeFuncs(negate, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(op('not', '!', B, [v(B, -1.0, 1.0)], f(1.0), f(0.0), na,{'scalar': es3fShaderOperatorTests.unaryGenTypeFuncs(boolNot, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL).scalar}));
   unary.push(op('bitwise_not', '~', IGT, [v(IGT, -1e5, 1e5)], f(5e-5), f(0.5), highp,
       es3fShaderOperatorTests.unaryGenTypeFuncs(bitwiseNot, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(op('bitwise_not', '~', UGT, [v(UGT, 0.0, 2e9)], f(2e-10), f(0.0), highp,
       es3fShaderOperatorTests.unaryGenTypeFuncs(bitwiseNot, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));

   // Pre/post incr/decr side effect cases.
   unary = new es3fShaderOperatorTests.BuiltinFuncGroup('unary_operator', 'Unary operator tests');
   funcInfoGroups.push(unary);

   unary.push(side('pre_increment_effect', '++', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne)));
   unary.push(side('pre_increment_effect', '++', IGT, [v(IGT, -6.0, 4.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(side('pre_increment_effect', '++', UGT, [v(UGT, 0.0, 9.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(side('pre_decrement_effect', '--', GT, [v(GT, -1.0, 1.0)], f(0.5), f(1.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne)));
   unary.push(side('pre_decrement_effect', '--', IGT, [v(IGT, -4.0, 6.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(side('pre_decrement_effect', '--', UGT, [v(UGT, 0.0, 10.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(postSide('post_increment_result', '++', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne)));
   unary.push(postSide('post_increment_result', '++', IGT, [v(IGT, -6.0, 4.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(postSide('post_increment_result', '++', UGT, [v(UGT, 0.0, 9.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(postSide('post_decrement_result', '--', GT, [v(GT, -1.0, 1.0)], f(0.5), f(1.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne)));
   unary.push(postSide('post_decrement_result', '--', IGT, [v(IGT, -4.0, 6.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(postSide('post_decrement_result', '--', UGT, [v(UGT, 1.0, 10.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));

   // Pre/post incr/decr result cases.
   unary = new es3fShaderOperatorTests.BuiltinFuncGroup('unary_operator', 'Unary operator tests');
   funcInfoGroups.push(unary);

   unary.push(op('pre_increment_result', '++', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne)));
   unary.push(op('pre_increment_result', '++', IGT, [v(IGT, -6.0, 4.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(op('pre_increment_result', '++', UGT, [v(UGT, 0.0, 9.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(addOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(op('pre_dencrement_result', '--', GT, [v(GT, -1.0, 1.0)], f(0.5), f(1.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne)));
   unary.push(op('pre_decrement_result', '--', IGT, [v(IGT, -4.0, 6.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(op('pre_decrement_result', '--', UGT, [v(UGT, 0.0, 10.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(subOne, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(postOp('post_increment_result', '++', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop)));
   unary.push(postOp('post_increment_result', '++', IGT, [v(IGT, -5.0, 5.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(postOp('post_increment_result', '++', UGT, [v(UGT, 0.0, 9.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   unary.push(postOp('post_decrement_result', '--', GT, [v(GT, -1.0, 1.0)], f(0.5), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop)));
   unary.push(postOp('post_decrement_result', '--', IGT, [v(IGT, -5.0, 5.0)], f(0.1), f(0.5), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   unary.push(postOp('post_decrement_result', '--', UGT, [v(UGT, 1.0, 10.0)], f(0.1), f(0.0), all,
       es3fShaderOperatorTests.unaryGenTypeFuncs(nop, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));

   var binary;

   // Normal binary operations and their corresponding assignment operations have lots in common; generate both in the following loop.
   // 0: normal op test, 1: assignment op side-effect test, 2: assignment op result test
   for (var binaryOperatorType = 0; binaryOperatorType <= 2; binaryOperatorType++) {
       var isNormalOp = binaryOperatorType == 0;
       var isAssignEff = binaryOperatorType == 1;
       var isAssignRes = binaryOperatorType == 2;

       var addName = isNormalOp ? 'add' : isAssignEff ? 'add_assign_effect' : 'add_assign_result';
       var subName = isNormalOp ? 'sub' : isAssignEff ? 'sub_assign_effect' : 'sub_assign_result';
       var mulName = isNormalOp ? 'mul' : isAssignEff ? 'mul_assign_effect' : 'mul_assign_result';
       var divName = isNormalOp ? 'div' : isAssignEff ? 'div_assign_effect' : 'div_assign_result';
       var modName = isNormalOp ? 'mod' : isAssignEff ? 'mod_assign_effect' : 'mod_assign_result';
       var andName = isNormalOp ? 'bitwise_and' : isAssignEff ? 'bitwise_and_assign_effect' : 'bitwise_and_assign_result';
       var orName = isNormalOp ? 'bitwise_or' : isAssignEff ? 'bitwise_or_assign_effect' : 'bitwise_or_assign_result';
       var xorName = isNormalOp ? 'bitwise_xor' : isAssignEff ? 'bitwise_xor_assign_effect' : 'bitwise_xor_assign_result';
       var leftShiftName = isNormalOp ? 'left_shift' : isAssignEff ? 'left_shift_assign_effect' : 'left_shift_assign_result';
       var rightShiftName = isNormalOp ? 'right_shift' : isAssignEff ? 'right_shift_assign_effect' : 'right_shift_assign_result';
       var addOp = isNormalOp ? '+' : '+=';
       var subOp = isNormalOp ? '-' : '-=';
       var mulOp = isNormalOp ? '*' : '*=';
       var divOp = isNormalOp ? '/' : '/=';
       var modOp = isNormalOp ? '%' : '%=';
       var andOp = isNormalOp ? '&' : '&=';
       var orOp = isNormalOp ? '|' : '|=';
       var xorOp = isNormalOp ? '^' : '^=';
       var leftShiftOp = isNormalOp ? '<<' : '<<=';
       var rightShiftOp = isNormalOp ? '>>' : '>>=';

       op = isAssignEff ? es3fShaderOperatorTests.builtinSideEffOperInfo : es3fShaderOperatorTests.builtinOperInfo;

       binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
       funcInfoGroups.push(binary);

       // The add operator.

       binary.push(op(addName, addOp, GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryGenTypeFuncs(add)));
       binary.push(op(addName, addOp, IGT, [v(IGT, -4.0, 6.0), v(IGT, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(add, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(addName, addOp, IGT, [v(IGT, -2e9, 2e9), v(IGT, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(add, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(addName, addOp, UGT, [v(UGT, 0.0, 1e2), v(UGT, 0.0, 1e2)], f(5e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(add, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(addName, addOp, UGT, [v(UGT, 0.0, 4e9), v(UGT, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(add, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       binary.push(op(addName, addOp, FV, [v(FV, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.addScalar)));
       binary.push(op(addName, addOp, IV, [v(IV, -4.0, 6.0), v(I, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.addScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(addName, addOp, IV, [v(IV, -2e9, 2e9), v(I, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.addScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(addName, addOp, UV, [v(UV, 0.0, 1e2), v(U, 0.0, 1e2)], f(5e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.addScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(addName, addOp, UV, [v(UV, 0.0, 4e9), v(U, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.addScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(addName, addOp, FV, [v(F, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
               all, es3fShaderOperatorTests.binaryScalarVecFuncs(addScalarVec)));
           binary.push(op(addName, addOp, IV, [v(I, -4.0, 6.0), v(IV, -6.0, 5.0)], f(0.1), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(addScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(addName, addOp, IV, [v(I, -2e9, 2e9), v(IV, -2e9, 2e9)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(addScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(addName, addOp, UV, [v(U, 0.0, 1e2), v(UV, 0.0, 1e2)], f(5e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(addScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(addName, addOp, UV, [v(U, 0.0, 4e9), v(UV, 0.0, 4e9)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(addScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       // The subtract operator.

       binary.push(op(subName, subOp, GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryGenTypeFuncs(sub)));
       binary.push(op(subName, subOp, IGT, [v(IGT, -4.0, 6.0), v(IGT, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(sub, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(subName, subOp, IGT, [v(IGT, -2e9, 2e9), v(IGT, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(sub, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(subName, subOp, UGT, [v(UGT, 1e2, 2e2), v(UGT, 0.0, 1e2)], f(5e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(sub, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(subName, subOp, UGT, [v(UGT, .5e9, 3.7e9), v(UGT, 0.0, 3.9e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(sub, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(subName, subOp, FV, [v(FV, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.subScalar)));
       binary.push(op(subName, subOp, IV, [v(IV, -4.0, 6.0), v(I, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.subScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(subName, subOp, IV, [v(IV, -2e9, 2e9), v(I, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.subScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(subName, subOp, UV, [v(UV, 1e2, 2e2), v(U, 0.0, 1e2)], f(5e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.subScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(subName, subOp, UV, [v(UV, 0.0, 4e9), v(U, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.subScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(subName, subOp, FV, [v(F, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
               all, es3fShaderOperatorTests.binaryScalarVecFuncs(subScalarVec)));
           binary.push(op(subName, subOp, IV, [v(I, -4.0, 6.0), v(IV, -6.0, 5.0)], f(0.1), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(subScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(subName, subOp, IV, [v(I, -2e9, 2e9), v(IV, -2e9, 2e9)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(subScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(subName, subOp, UV, [v(U, 1e2, 2e2), v(UV, 0.0, 1e2)], f(5e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(subScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(subName, subOp, UV, [v(U, 0.0, 4e9), v(UV, 0.0, 4e9)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(subScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
       funcInfoGroups.push(binary);

       // The multiply operator.

       binary.push(op(mulName, mulOp, GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryGenTypeFuncs(mul)));
       binary.push(op(mulName, mulOp, IGT, [v(IGT, -4.0, 6.0), v(IGT, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(mul, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(mulName, mulOp, IGT, [v(IGT, -3e5, 3e5), v(IGT, -3e4, 3e4)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(mul, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(mulName, mulOp, UGT, [v(UGT, 0.0, 16.0), v(UGT, 0.0, 16.0)], f(4e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(mul, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(mulName, mulOp, UGT, [v(UGT, 0.0, 6e5), v(UGT, 0.0, 6e4)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(mul, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(mulName, mulOp, FV, [v(FV, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.scale)));
       binary.push(op(mulName, mulOp, IV, [v(IV, -4.0, 6.0), v(I, -6.0, 5.0)], f(0.1), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.scale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(mulName, mulOp, IV, [v(IV, -3e5, 3e5), v(I, -3e4, 3e4)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.scale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(mulName, mulOp, UV, [v(UV, 0.0, 16.0), v(U, 0.0, 16.0)], f(4e-3), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.scale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(mulName, mulOp, UV, [v(UV, 0.0, 6e5), v(U, 0.0, 6e4)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.scale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(mulName, mulOp, FV, [v(F, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
               all, es3fShaderOperatorTests.binaryScalarVecFuncs(mulScalarVec)));
           binary.push(op(mulName, mulOp, IV, [v(I, -4.0, 6.0), v(IV, -6.0, 5.0)], f(0.1), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(mulScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(mulName, mulOp, IV, [v(I, -3e5, 3e5), v(IV, -3e4, 3e4)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(mulScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(mulName, mulOp, UV, [v(U, 0.0, 16.0), v(UV, 0.0, 16.0)], f(4e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(mulScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(mulName, mulOp, UV, [v(U, 0.0, 6e5), v(UV, 0.0, 6e4)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(mulScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       // The divide operator.

       binary.push(op(divName, divOp, GT, [v(GT, -1.0, 1.0), v(GT, -2.0, -0.5)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryGenTypeFuncs(div)));
       binary.push(op(divName, divOp, IGT, [v(IGT, 24.0, 24.0), v(IGT, -4.0, -1.0)], f(0.04), f(1.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(div, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(divName, divOp, IGT, [v(IGT, 40320.0, 40320.0), v(IGT, -8.0, -1.0)], f(1e-5), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(div, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(divName, divOp, UGT, [v(UGT, 0.0, 24.0), v(UGT, 1.0, 4.0)], f(0.04), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(div, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(divName, divOp, UGT, [v(UGT, 0.0, 40320.0), v(UGT, 1.0, 8.0)], f(1e-5), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(div, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(divName, divOp, FV, [v(FV, -1.0, 1.0), v(F, -2.0, -0.5)], f(1.0), f(0.0),
           all, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.divideScale)));
       binary.push(op(divName, divOp, IV, [v(IV, 24.0, 24.0), v(I, -4.0, -1.0)], f(0.04), f(1.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.divideScale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(divName, divOp, IV, [v(IV, 40320.0, 40320.0), v(I, -8.0, -1.0)], f(1e-5), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.divideScale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(divName, divOp, UV, [v(UV, 0.0, 24.0), v(U, 1.0, 4.0)], f(0.04), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.divideScale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(divName, divOp, UV, [v(UV, 0.0, 40320.0), v(U, 1.0, 8.0)], f(1e-5), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.divideScale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(divName, divOp, FV, [v(F, -1.0, 1.0), v(FV, -2.0, -0.5)], f(1.0), f(0.0),
               all, es3fShaderOperatorTests.binaryScalarVecFuncs(divScalarVec)));
           binary.push(op(divName, divOp, IV, [v(I, 24.0, 24.0), v(IV, -4.0, -1.0)], f(0.04), f(1.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(divScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(divName, divOp, IV, [v(I, 40320.0, 40320.0), v(IV, -8.0, -1.0)], f(1e-5), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(divScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(divName, divOp, UV, [v(U, 0.0, 24.0), v(UV, 1.0, 4.0)], f(0.04), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(divScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(divName, divOp, UV, [v(U, 0.0, 40320.0), v(UV, 1.0, 8.0)], f(1e-5), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(divScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
       funcInfoGroups.push(binary);

       // The modulus operator.

       binary.push(op(modName, modOp, IGT, [v(IGT, 0.0, 6.0), v(IGT, 1.1, 6.1)], f(0.25), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.mod, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(modName, modOp, IGT, [v(IGT, 0.0, 14.0), v(IGT, 1.1, 11.1)], f(0.1), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.mod, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(modName, modOp, UGT, [v(UGT, 0.0, 6.0), v(UGT, 1.1, 6.1)], f(0.25), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.mod, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(modName, modOp, UGT, [v(UGT, 0.0, 24.0), v(UGT, 1.1, 11.1)], f(0.1), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.mod, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(modName, modOp, IV, [v(IV, 0.0, 6.0), v(I, 1.1, 6.1)], f(0.25), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.modScale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(modName, modOp, IV, [v(IV, 0.0, 6.0), v(I, 1.1, 11.1)], f(0.1), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.modScale, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(modName, modOp, UV, [v(UV, 0.0, 6.0), v(U, 1.1, 6.1)], f(0.25), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.modScale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(modName, modOp, UV, [v(UV, 0.0, 24.0), v(U, 1.1, 11.1)], f(0.1), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.modScale, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(modName, modOp, IV, [v(I, 0.0, 6.0), v(IV, 1.1, 6.1)], f(0.25), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(modScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(modName, modOp, IV, [v(I, 0.0, 6.0), v(IV, 1.1, 11.1)], f(0.1), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(modScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(modName, modOp, UV, [v(U, 0.0, 6.0), v(UV, 1.1, 6.1)], f(0.25), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(modScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(modName, modOp, UV, [v(U, 0.0, 24.0), v(UV, 1.1, 11.1)], f(0.1), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(modScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       // The bitwise and operator.

       binary.push(op(andName, andOp, IGT, [v(IGT, -16.0, 16.0), v(IGT, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryAnd, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(andName, andOp, IGT, [v(IGT, -2e9, 2e9), v(IGT, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryAnd, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(andName, andOp, UGT, [v(UGT, 0.0, 32.0), v(UGT, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryAnd, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(andName, andOp, UGT, [v(UGT, 0.0, 4e9), v(UGT, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryAnd, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(andName, andOp, IV, [v(IV, -16.0, 16.0), v(I, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryAndVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(andName, andOp, IV, [v(IV, -2e9, 2e9), v(I, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryAndVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(andName, andOp, UV, [v(UV, 0.0, 32.0), v(U, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryAndVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(andName, andOp, UV, [v(UV, 0.0, 4e9), v(U, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryAndVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(andName, andOp, IV, [v(I, -16.0, 16.0), v(IV, -16.0, 16.0)], f(0.03), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseAndScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(andName, andOp, IV, [v(I, -2e9, 2e9), v(IV, -2e9, 2e9)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseAndScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(andName, andOp, UV, [v(U, 0.0, 32.0), v(UV, 0.0, 32.0)], f(0.03), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseAndScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(andName, andOp, UV, [v(U, 0.0, 4e9), v(UV, 0.0, 4e9)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseAndScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
       funcInfoGroups.push(binary);

       // The bitwise or operator.

       binary.push(op(orName, orOp, IGT, [v(IGT, -16.0, 16.0), v(IGT, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryOr, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(orName, orOp, IGT, [v(IGT, -2e9, 2e9), v(IGT, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryOr, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(orName, orOp, UGT, [v(UGT, 0.0, 32.0), v(UGT, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryOr, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(orName, orOp, UGT, [v(UGT, 0.0, 4e9), v(UGT, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryOr, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(orName, orOp, IV, [v(IV, -16.0, 16.0), v(I, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryOrVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(orName, orOp, IV, [v(IV, -2e9, 2e9), v(I, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryOrVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(orName, orOp, UV, [v(UV, 0.0, 32.0), v(U, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryOrVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(orName, orOp, UV, [v(UV, 0.0, 4e9), v(U, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryOrVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(orName, orOp, IV, [v(I, -16.0, 16.0), v(IV, -16.0, 16.0)], f(0.03), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseOrScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(orName, orOp, IV, [v(I, -2e9, 2e9), v(IV, -2e9, 2e9)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseOrScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(orName, orOp, UV, [v(U, 0.0, 32.0), v(UV, 0.0, 32.0)], f(0.03), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseOrScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(orName, orOp, UV, [v(U, 0.0, 4e9), v(UV, 0.0, 4e9)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseOrScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       // The bitwise xor operator.

       binary.push(op(xorName, xorOp, IGT, [v(IGT, -16.0, 16.0), v(IGT, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryXor, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(xorName, xorOp, IGT, [v(IGT, -2e9, 2e9), v(IGT, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryXor, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(xorName, xorOp, UGT, [v(UGT, 0.0, 32.0), v(UGT, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryXor, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(xorName, xorOp, UGT, [v(UGT, 0.0, 4e9), v(UGT, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.binaryXor, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(xorName, xorOp, IV, [v(IV, -16.0, 16.0), v(I, -16.0, 16.0)], f(0.03), f(0.5),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryXorVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(xorName, xorOp, IV, [v(IV, -2e9, 2e9), v(I, -2e9, 2e9)], f(4e-10), f(0.5),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryXorVecScalar, gluShaderUtil.DataType.INT,
           gluShaderUtil.DataType.INT)));
       binary.push(op(xorName, xorOp, UV, [v(UV, 0.0, 32.0), v(U, 0.0, 32.0)], f(0.03), f(0.0),
           mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryXorVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));
       binary.push(op(xorName, xorOp, UV, [v(UV, 0.0, 4e9), v(U, 0.0, 4e9)], f(2e-10), f(0.0),
           highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.binaryXorVecScalar, gluShaderUtil.DataType.UINT,
           gluShaderUtil.DataType.UINT)));

       if (isNormalOp) {
           binary.push(op(xorName, xorOp, IV, [v(I, -16.0, 16.0), v(IV, -16.0, 16.0)], f(0.03), f(0.5),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseXorScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(xorName, xorOp, IV, [v(I, -2e9, 2e9), v(IV, -2e9, 2e9)], f(4e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseXorScalarVec, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(xorName, xorOp, UV, [v(U, 0.0, 32.0), v(UV, 0.0, 32.0)], f(0.03), f(0.0),
               mediump, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseXorScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(xorName, xorOp, UV, [v(U, 0.0, 4e9), v(UV, 0.0, 4e9)], f(2e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryScalarVecFuncs(bitwiseXorScalarVec, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
       funcInfoGroups.push(binary);

       // The left shift operator. Second operand (shift amount) can be either int or uint, even for uint and int first operand, respectively.
       for (var isSignedAmount = 0; isSignedAmount <= 1; isSignedAmount++) {
           var gType = isSignedAmount == 0 ? UGT : IGT;
           var sType = isSignedAmount == 0 ? U : I;
           binary.push(op(leftShiftName, leftShiftOp, IGT, [v(IGT, -7.0, 7.0), v(gType, 0.0, 4.0)], f(4e-3), f(0.5),
               mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftLeft, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(leftShiftName, leftShiftOp, IGT, [v(IGT, -7.0, 7.0), v(gType, 0.0, 27.0)], f(5e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftLeft, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(leftShiftName, leftShiftOp, UGT, [v(UGT, 0.0, 7.0), v(gType, 0.0, 5.0)], f(4e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftLeft, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(leftShiftName, leftShiftOp, UGT, [v(UGT, 0.0, 7.0), v(gType, 0.0, 28.0)], f(5e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftLeft, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(leftShiftName, leftShiftOp, IV, [v(IV, -7.0, 7.0), v(sType, 0.0, 4.0)], f(4e-3), f(0.5),
               mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftLeftVecScalar, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(leftShiftName, leftShiftOp, IV, [v(IV, -7.0, 7.0), v(sType, 0.0, 27.0)], f(5e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftLeftVecScalar, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(leftShiftName, leftShiftOp, UV, [v(UV, 0.0, 7.0), v(sType, 0.0, 5.0)], f(4e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftLeftVecScalar, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(leftShiftName, leftShiftOp, UV, [v(UV, 0.0, 7.0), v(sType, 0.0, 28.0)], f(5e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftLeftVecScalar, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }

       // The right shift operator. Second operand (shift amount) can be either int or uint, even for uint and int first operand, respectively.

       for (var isSignedAmount = 0; isSignedAmount <= 1; isSignedAmount++) {
           gType = isSignedAmount == 0 ? UGT : IGT;
           sType = isSignedAmount == 0 ? U : I;
           binary.push(op(rightShiftName, rightShiftOp, IGT, [v(IGT, -127.0, 127.0), v(gType, 0.0, 8.0)], f(4e-3), f(0.5),
               mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftRight, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(rightShiftName, rightShiftOp, IGT, [v(IGT, -2e9, 2e9), v(gType, 0.0, 31.0)], f(5e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftRight, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(rightShiftName, rightShiftOp, UGT, [v(UGT, 0.0, 255.0), v(gType, 0.0, 8.0)], f(4e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftRight, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(rightShiftName, rightShiftOp, UGT, [v(UGT, 0.0, 4e9), v(gType, 0.0, 31.0)], f(5e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.shiftRight, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(rightShiftName, rightShiftOp, IV, [v(IV, -127.0, 127.0), v(sType, 0.0, 8.0)], f(4e-3), f(0.5),
               mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftRightVecScalar, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(rightShiftName, rightShiftOp, IV, [v(IV, -2e9, 2e9), v(sType, 0.0, 31.0)], f(5e-10), f(0.5),
               highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftRightVecScalar, gluShaderUtil.DataType.INT,
               gluShaderUtil.DataType.INT)));
           binary.push(op(rightShiftName, rightShiftOp, UV, [v(UV, 0.0, 255.0), v(sType, 0.0, 8.0)], f(4e-3), f(0.0),
               mediump, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftRightVecScalar, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
           binary.push(op(rightShiftName, rightShiftOp, UV, [v(UV, 0.0, 4e9), v(sType, 0.0, 31.0)], f(5e-10), f(0.0),
               highp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.shiftRightVecScalar, gluShaderUtil.DataType.UINT,
               gluShaderUtil.DataType.UINT)));
       }
   }

   // Rest of binary operators.
   // Scalar relational operators.
   binary = new es3fShaderOperatorTests.BuiltinFuncGroup('binary_operator', 'Binary operator tests');
   funcInfoGroups.push(binary);

   binary.push(op('less', '<', B, [v(F, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThan).scalar}));
   binary.push(op('less', '<', B, [v(I, -5.0, 5.0), v(I, -5.0, 5.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThan, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT).scalar}));
   binary.push(op('less', '<', B, [v(U, 0.0, 16.0), v(U, 0.0, 16.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThan, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT).scalar}));
   binary.push(op('less_or_equal', '<=', B, [v(F, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThanEqual).scalar}));
   binary.push(op('less_or_equal', '<=', B, [v(I, -5.0, 5.0), v(I, -5.0, 5.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThanEqual, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT).scalar}));
   binary.push(op('less_or_equal', '<=', B, [v(U, 0.0, 16.0), v(U, 0.0, 16.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(lessThanEqual, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT).scalar}));
   binary.push(op('greater', '>', B, [v(F, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThan).scalar}));
   binary.push(op('greater', '>', B, [v(I, -5.0, 5.0), v(I, -5.0, 5.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThan, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT).scalar}));
   binary.push(op('greater', '>', B, [v(U, 0.0, 16.0), v(U, 0.0, 16.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThan, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT).scalar}));
   binary.push(op('greater_or_equal', '>=', B, [v(F, -1.0, 1.0), v(F, -1.0, 1.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThanEqual).scalar}));
   binary.push(op('greater_or_equal', '>=', B, [v(I, -5.0, 5.0), v(I, -5.0, 5.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThanEqual, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT).scalar}));
   binary.push(op('greater_or_equal', '>=', B, [v(U, 0.0, 16.0), v(U, 0.0, 16.0)], f(1.0), f(0.0),
       all, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(greaterThanEqual, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT).scalar}));

   binary.push(op('equal', '==', B, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(allEqual)));
   binary.push(op('equal', '==', B, [v(IGT, -5.5, 4.7), v(IGT, -2.1, 0.1)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(allEqual, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   binary.push(op('equal', '==', B, [v(UGT, 0.0, 8.0), v(UGT, 3.5, 4.5)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(allEqual, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   binary.push(op('equal', '==', B, [v(BGT, -2.1, 2.1), v(BGT, -1.1, 3.0)], f(1.0), f(0.0),
       na, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(allEqual, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL)));
   binary.push(op('not_equal', '!=', B, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(anyNotEqual)));
   binary.push(op('not_equal', '!=', B, [v(IGT, -5.5, 4.7), v(IGT, -2.1, 0.1)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(anyNotEqual, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   binary.push(op('not_equal', '!=', B, [v(UGT, 0.0, 8.0), v(UGT, 3.5, 4.5)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(anyNotEqual, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   binary.push(op('not_equal', '!=', B, [v(BGT, -2.1, 2.1), v(BGT, -1.1, 3.0)], f(1.0), f(0.0),
       na, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(anyNotEqual, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL)));

   // Logical operators.
   binary.push(op('logical_and', '&&', B, [v(B, -1.0, 1.0), v(B, -1.0, 1.0)], f(1.0), f(0.0),
       na, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(logicalAnd, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL).scalar}));
   binary.push(op('logical_or', '||', B, [v(B, -1.0, 1.0), v(B, -1.0, 1.0)], f(1.0), f(0.0),
       na, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(logicalOr, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL).scalar}));
   binary.push(op('logical_xor', '^^', B, [v(B, -1.0, 1.0), v(B, -1.0, 1.0)], f(1.0), f(0.0),
       na, {scalar: es3fShaderOperatorTests.binaryGenTypeFuncs(logicalXor, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL).scalar}));

   // 8.1 Angle and Trigonometry Functions.
   var trig = new es3fShaderOperatorTests.BuiltinFuncGroup("angle_and_trigonometry", "Angle and trigonometry function tests.");
   funcInfoGroups.push(trig);
   op = es3fShaderOperatorTests.builtinFunctionInfo;
   trig.push(op("radians", "radians", GT, [v(GT, -1.0, 1.0)], f(25.0), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(radians)));
   trig.push(op("degrees", "degrees", GT, [v(GT, -1.0, 1.0)], f(0.04), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(degrees)));
   trig.push(op("sin", "sin", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sin)));
   trig.push(op("sin", "sin", GT, [v(GT, -1.5, 1.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sin)));
   trig.push(op("cos", "cos", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.cos)));
   trig.push(op("cos", "cos", GT, [v(GT, -1.5, 1.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.cos)));
   trig.push(op("tan", "tan", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.tan)));
   trig.push(op("tan", "tan", GT, [v(GT, -1.5, 5.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.tan)));

   trig = new es3fShaderOperatorTests.BuiltinFuncGroup("angle_and_trigonometry", "Angle and trigonometry function tests.");
   funcInfoGroups.push(trig);
   trig.push(op("asin", "asin", GT, [v(GT, -1.0, 1.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.asin)));
   trig.push(op("acos", "acos", GT, [v(GT, -1.0, 1.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.acos)));
   trig.push(op("atan", "atan", GT, [v(GT, -4.0, 4.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.atan)));
   trig.push(op("atan2", "atan", GT, [v(GT, -4.0, 4.0), v(GT, 0.5, 2.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.atan2)));

   trig = new es3fShaderOperatorTests.BuiltinFuncGroup("angle_and_trigonometry", "Angle and trigonometry function tests.");
   funcInfoGroups.push(trig);
   trig.push(op("sinh", "sinh", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sinh)));
   trig.push(op("sinh", "sinh", GT, [v(GT, -1.5, 1.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sinh)));
   trig.push(op("cosh", "cosh", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.cosh)));
   trig.push(op("cosh", "cosh", GT, [v(GT, -1.5, 1.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.cosh)));
   trig.push(op("tanh", "tanh", GT, [v(GT, -5.0, 5.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.tanh)));
   trig.push(op("tanh", "tanh", GT, [v(GT, -1.5, 5.5)], f(0.5), f(0.5),
       lowp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.tanh)));

   trig = new es3fShaderOperatorTests.BuiltinFuncGroup("angle_and_trigonometry", "Angle and trigonometry function tests.");
   funcInfoGroups.push(trig);
   trig.push(op("asinh", "asinh", GT, [v(GT, -1.0, 1.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.asinh)));
   trig.push(op("acosh", "acosh", GT, [v(GT, 1.0, 2.2)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.acosh)));
   // Results are undefined if |x| >= 1, so it diverses from C++ version here.
   trig.push(op("atanh", "atanh", GT, [v(GT, -0.99, 0.99)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.atanh)));

   // 8.2 Exponential Functions.
   var exps = new es3fShaderOperatorTests.BuiltinFuncGroup("exponential", "Exponential function tests");
   exps.push(op("pow", "pow", GT, [v(GT, 0.1, 8.0), v(GT, -4.0, 2.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.pow)));
   exps.push(op("exp", "exp", GT, [v(GT, -6.0, 3.0)], f(0.5), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.exp)));
   exps.push(op("log", "log", GT, [v(GT, 0.1, 10.0)], f(0.5), f(0.3),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.log)));
   exps.push(op("exp2", "exp2", GT, [v(GT, -7.0, 2.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(exp2)));
   exps.push(op("log2", "log2", GT, [v(GT, 0.1, 10.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.log2)));
   exps.push(op("sqrt", "sqrt", GT, [v(GT, 0.0, 10.0)], f(0.3), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sqrt)));
   exps.push(op("inversesqrt", "inversesqrt", GT, [v(GT, 0.5, 10.0)], f(1.0), f(0.0),
       mediumhighp, es3fShaderOperatorTests.unaryGenTypeFuncs(inverseSqrt)));

   funcInfoGroups.push(exps);

   // 8.3 Common Functions.
   var comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);
   comm.push(op("abs", "abs", GT, [v(GT, -2.0, 2.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.abs)));
   comm.push(op("sign", "sign", GT, [v(GT, -1.5, 1.5)], f(0.3), f(0.5),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.sign)));
   comm.push(op("floor", "floor", GT, [v(GT, 2.5, 2.5)], f(0.2), f(0.7),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.floor)));
   comm.push(op("trunc", "trunc", GT, [v(GT, 2.5, 2.5)], f(0.2), f(0.7),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.trunc)));
   comm.push(op("round", "round", GT, [v(GT, 2.5, 2.5)], f(0.2), f(0.7),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(roundToEven)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("roundEven", "roundEven", GT, [v(GT, 2.5, 2.5)], f(0.2), f(0.7),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(roundToEven)));
   comm.push(op("ceil", "ceil", GT, [v(GT, 2.5, 2.5)], f(0.2), f(0.5),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(Math.ceil)));
   comm.push(op("fract", "fract", GT, [v(GT, -1.5, 1.5)], f(0.8), f(0.1),
       all, es3fShaderOperatorTests.unaryGenTypeFuncs(fract)));
   comm.push(op("mod", "mod", GT, [v(GT, -2.0, 2.0), v(GT, 0.9, 6.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryGenTypeFuncs(deMath.mod)));
   comm.push(op("mod", "mod", GT, [v(FV, -2.0, 2.0), v(F, 0.9, 6.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryVecScalarFuncs(deMath.modScale)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("min", "min", GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.min)));
   comm.push(op("min", "min", GT, [v(FV, -1.0, 1.0), v(F, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(minVecScalar)));
   comm.push(op("min", "min", IGT, [v(IGT, -4.0, 4.0), v(IGT, -4.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.min, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   comm.push(op("min", "min", IGT, [v(IV, -4.0, 4.0), v(I, -4.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(minVecScalar, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   comm.push(op("min", "min", UGT, [v(UGT, 0.0, 8.0), v(UGT, 0.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.min, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("min", "min", UGT, [v(UV, 0.0, 8.0), v(U, 0.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(minVecScalar, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   comm.push(op("max", "max", GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.max)));
   comm.push(op("max", "max", GT, [v(FV, -1.0, 1.0), v(F, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(maxVecScalar)));
   comm.push(op("max", "max", IGT, [v(IGT, -4.0, 4.0), v(IGT, -4.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.max, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   comm.push(op("max", "max", IGT, [v(IV, -4.0, 4.0), v(I, -4.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(maxVecScalar, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("max", "max", UGT, [v(UGT, 0.0, 8.0), v(UGT, 0.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(Math.max, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   comm.push(op("max", "max", UGT, [v(UV, 0.0, 8.0), v(U, 0.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.binaryVecScalarFuncs(maxVecScalar, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   comm.push(op("clamp", "clamp", GT, [v(GT, -1.0, 1.0), v(GT, -0.5, 0.5), v(GT, 0.5, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryGenTypeFuncs(deMath.clamp)));
   comm.push(op("clamp", "clamp", GT, [v(FV, -1.0, 1.0), v(F, -0.5, 0.5), v(F, 0.5, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryVecScalarScalarFuncs(clampVecScalarScalar)));
   comm.push(op("clamp", "clamp", IGT, [v(IGT, -4.0, 4.0), v(IGT, -2.0, 2.0), v(IGT, 2.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.ternaryGenTypeFuncs(deMath.clamp, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("clamp", "clamp", IGT, [v(IGT, -4.0, 4.0), v(I, -2.0, 2.0), v(I, 2.0, 4.0)], f(0.125), f(0.5),
       all, es3fShaderOperatorTests.ternaryVecScalarScalarFuncs(clampVecScalarScalar, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   comm.push(op("clamp", "clamp", UGT, [v(UGT, 0.0, 8.0), v(UGT, 2.0, 6.0), v(UGT, 6.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.ternaryGenTypeFuncs(deMath.clamp, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   comm.push(op("clamp", "clamp", UGT, [v(UV, 0.0, 8.0), v(U, 2.0, 6.0), v(U, 6.0, 8.0)], f(0.125), f(0.0),
       all, es3fShaderOperatorTests.ternaryVecScalarScalarFuncs(clampVecScalarScalar, gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT)));
   comm.push(op("mix", "mix", GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 1.0), v(GT, 0.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryGenTypeFuncs(mix)));
   comm.push(op("mix", "mix", GT, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0), v(F, 0.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryVecVecScalarFuncs(mixVecVecScalar)));

   comm = new es3fShaderOperatorTests.BuiltinFuncGroup("common_functions", "Common function tests.");
   funcInfoGroups.push(comm);

   comm.push(op("step", "step", GT, [v(GT, -1.0, 1.0), v(GT, -1.0, 0.0)], f(0.5), f(0.25),
       all, es3fShaderOperatorTests.binaryGenTypeFuncs(step)));
   comm.push(op("step", "step", GT, [v(F, -1.0, 1.0), v(FV, -1.0, 0.0)], f(0.5), f(0.25),
       all, es3fShaderOperatorTests.binaryScalarVecFuncs(stepScalarVec)));
   comm.push(op("smoothstep", "smoothstep", GT, [v(GT, -0.5, 0.0), v(GT, 0.1, 1.0), v(GT, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryGenTypeFuncs(smoothStep)));
   comm.push(op("smoothstep", "smoothstep", GT, [v(F, -0.5, 0.0), v(F, 0.1, 1.0), v(FV, -1.0, 1.0)], f(0.5), f(0.5),
       all, es3fShaderOperatorTests.ternaryScalarScalarVecFuncs(smoothStepScalarScalarVec)));

   // 8.4 Geometric Functions.
   var geom = new es3fShaderOperatorTests.BuiltinFuncGroup("geometric", "Geometric function tests.");
   geom.push(op("length", "length", F, [v(GT, -5.0, 5.0)], f(0.1), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryScalarGenTypeFuncs(length)));
   geom.push(op("distance", "distance", F, [v(GT, -5.0, 5.0), v(GT, -5.0, 5.0)], f(0.1), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(distance)));
   geom.push(op("dot", "dot", F, [v(GT, -5.0, 5.0), v(GT, -5.0, 5.0)], f(0.1), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryScalarGenTypeFuncs(dot)));
   geom.push(op("cross", "cross", V3, [v(GT, -5.0, 5.0), v(GT, -5.0, 5.0)], f(0.1), f(0.5),
       mediumhighp, {vec3: es3fShaderOperatorTests.binaryVecVecFuncs(cross).vec3}));
   geom.push(op("normalize", "normalize", GT, [v(GT, 0.1, 4.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.unaryArrayFuncs(normalize)));
   geom.push(op("faceforward", "faceforward", GT, [v(GT, -5.0, 5.0), v(GT, -5.0, 5.0), v(GT, -1.0, 1.0)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.ternaryVecVecVecFuncs(faceforward)));
   geom.push(op("reflect", "reflect", GT, [v(GT, -0.8, -0.5), v(GT, 0.5, 0.8)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.binaryVecVecFuncs(reflect)));
   geom.push(op("refract", "refract", GT, [v(GT, -0.8, 1.2), v(GT, -1.1, 0.5), v(F, 0.2, 1.5)], f(0.5), f(0.5),
       mediumhighp, es3fShaderOperatorTests.ternaryVecVecScalarFuncs(refract)));

   funcInfoGroups.push(geom);

   // 8.6 Vector Relational Functions.
   var floatComp = new es3fShaderOperatorTests.BuiltinFuncGroup("float_compare", "Floating point comparison tests.");
   floatComp.push(op("lessThan", "lessThan", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(lessThanVec)));
   floatComp.push(op("lessThanEqual", "lessThanEqual", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(lessThanEqualVec)));
   floatComp.push(op("greaterThan", "greaterThan", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(greaterThanVec)));
   floatComp.push(op("greaterThanEqual", "greaterThanEqual", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(greaterThanEqualVec)));
   floatComp.push(op("equal", "equal", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(allEqualVec)));
   floatComp.push(op("notEqual", "notEqual", BV, [v(FV, -1.0, 1.0), v(FV, -1.0, 1.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(anyNotEqualVec)));

   funcInfoGroups.push(floatComp);

   var intComp = new es3fShaderOperatorTests.BuiltinFuncGroup("int_compare", "Integer comparison tests.");
   intComp.push(op("lessThan", "lessThan", BV, [v(IV, 5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(lessThanVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   intComp.push(op("lessThanEqual", "lessThanEqual", BV, [v(IV, -5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(lessThanEqualVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   intComp.push(op("greaterThan", "greaterThan", BV, [v(IV, -5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(greaterThanVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   intComp.push(op("greaterThanEqual", "greaterThanEqual", BV, [v(IV, -5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(greaterThanEqualVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   intComp.push(op("equal", "equal", BV, [v(IV, -5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(allEqualVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));
   intComp.push(op("notEqual", "notEqual", BV, [v(IV, -5.2, 4.9), v(IV, -5.0, 5.0)], f(1.0), f(0.0),
       all, es3fShaderOperatorTests.binaryVecVecFuncs(anyNotEqualVec, gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT)));

   funcInfoGroups.push(intComp);

   var boolComp = new es3fShaderOperatorTests.BuiltinFuncGroup("bool_compare", "Boolean comparison tests.");
   var evalBoolEqual = es3fShaderOperatorTests.binaryVecVecFuncs(allEqualVec, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL);
   var evalBoolNotEqual = es3fShaderOperatorTests.binaryVecVecFuncs(anyNotEqualVec, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL);
   var evalBoolAny = es3fShaderOperatorTests.unaryBooleanGenTypeFuncs(boolAny, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL);
   evalBoolAny.scalar = null;
   var evalBoolAll = es3fShaderOperatorTests.unaryBooleanGenTypeFuncs(boolAll, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL);
   evalBoolAll.scalar = null;
   var evalBoolNot = es3fShaderOperatorTests.unaryArrayFuncs(boolNotVec, gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL);
   evalBoolNot.scalar = null;

   boolComp.push(op("equal", "equal", BV, [v(BV, -5.2, 4.9), v(BV, -5.0, 5.0)], f(1.0), f(0.0),
       na, evalBoolEqual));
   boolComp.push(op("notEqual", "notEqual", BV, [v(BV, -5.2, 4.9), v(BV, -5.0, 5.0)], f(1.0), f(0.0),
       na, evalBoolNotEqual));
   boolComp.push(op("any", "any", B, [v(BV, -1.0, 0.3)], f(1.0), f(0.0),
       na, evalBoolAny));
   boolComp.push(op("all", "all", B, [v(BV, -0.3, 1.0)], f(1.0), f(0.0),
       na, evalBoolAll));
   boolComp.push(op("not", "not", BV, [v(BV, -1.0, 1.0)], f(1.0), f(0.0),
       na, evalBoolNot));

   funcInfoGroups.push(boolComp);

   var s_shaderTypes = [
       gluShaderProgram.shaderType.VERTEX,
       gluShaderProgram.shaderType.FRAGMENT
   ];

   var s_floatTypes = [
       gluShaderUtil.DataType.FLOAT,
       gluShaderUtil.DataType.FLOAT_VEC2,
       gluShaderUtil.DataType.FLOAT_VEC3,
       gluShaderUtil.DataType.FLOAT_VEC4
   ];

   var s_intTypes = [
       gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT_VEC2,
       gluShaderUtil.DataType.INT_VEC3,
       gluShaderUtil.DataType.INT_VEC4
   ];

   var s_uintTypes = [
       gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT_VEC2,
       gluShaderUtil.DataType.UINT_VEC3,
       gluShaderUtil.DataType.UINT_VEC4
   ];

   var s_boolTypes = [
       gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL_VEC2,
       gluShaderUtil.DataType.BOOL_VEC3,
       gluShaderUtil.DataType.BOOL_VEC4
   ];

   for (var outerGroupNdx = 0; outerGroupNdx < funcInfoGroups.length; outerGroupNdx++) {
       // Create outer group.
       var outerGroupInfo = funcInfoGroups[outerGroupNdx];
       var outerGroup = new tcuTestCase.DeqpTest(outerGroupInfo.name, outerGroupInfo.description);
       this.addChild(outerGroup);

       // Only create new group if name differs from previous one.
       var innerGroup = null;

       for (var funcInfoNdx = 0; funcInfoNdx < outerGroupInfo.funcInfos.length; funcInfoNdx++) {
           var funcInfo = outerGroupInfo.funcInfos[funcInfoNdx];
           var shaderFuncName = funcInfo.shaderFuncName;
           var isBoolCase = (funcInfo.precision == es3fShaderOperatorTests.Precision.None);
           var isBoolOut = es3fShaderOperatorTests.isBoolType(funcInfo.outValue);
           var isIntOut = es3fShaderOperatorTests.isIntType(funcInfo.outValue);
           var isUintOut = es3fShaderOperatorTests.isUintType(funcInfo.outValue);
           var isFloatOut = !isBoolOut && !isIntOut && !isUintOut;

           if (!innerGroup || (innerGroup.name != funcInfo.caseName)) {
               var groupDesc = 'Built-in function ' + shaderFuncName + '() tests.';
               innerGroup = new tcuTestCase.DeqpTest(funcInfo.caseName, groupDesc);
               outerGroup.addChild(innerGroup);
           }

           for (var inScalarSize = 1; inScalarSize <= 4; inScalarSize++) {
               var outScalarSize = ((funcInfo.outValue == es3fShaderOperatorTests.ValueType.FLOAT) || (funcInfo.outValue == es3fShaderOperatorTests.ValueType.BOOL)) ? 1 : inScalarSize; // \todo [petri] Int.
               var outDataType = isFloatOut ? s_floatTypes[outScalarSize - 1] :
                                           isIntOut ? s_intTypes[outScalarSize - 1] :
                                           isUintOut ? s_uintTypes[outScalarSize - 1] :
                                           isBoolOut ? s_boolTypes[outScalarSize - 1] :
                                           undefined;

               var evalFunc = null;
               if (inScalarSize == 1) evalFunc = funcInfo.evalFunctions.scalar;
               else if (inScalarSize == 2) evalFunc = funcInfo.evalFunctions.vec2;
               else if (inScalarSize == 3) evalFunc = funcInfo.evalFunctions.vec3;
               else if (inScalarSize == 4) evalFunc = funcInfo.evalFunctions.vec4;
               else throw new Error('Invalid scalar size ' + inScalarSize);

               // Skip if no valid eval func.
               // \todo [petri] Better check for V3 only etc. cases?
               if (evalFunc == null)
                   continue;

               var precisions = ['low', 'medium', 'high'];
               for (var precId = 0; precId < precisions.length; precId++) {
                   var precision = precisions[precId];
                   if ((funcInfo.precision[precision]) ||
                       (funcInfo.precision == es3fShaderOperatorTests.Precision.None && precision === 'medium')) { // use mediump interpolators for booleans
                       var precisionPrefix = isBoolCase ? '' : precision + 'p_';

                       for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
                           var shaderType = s_shaderTypes[shaderTypeNdx];
                           var shaderSpec = new es3fShaderOperatorTests.ShaderDataSpec();
                           var shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
                           var isVertexCase = shaderType == gluShaderProgram.shaderType.VERTEX;
                           var isUnaryOp = (funcInfo.inputs.length == 1);

                           // \note Data type names will be added to description and name in a following loop.
                           var desc = 'Built-in function ' + shaderFuncName + '(';
                           var name = precisionPrefix;

                           // Generate shader op.
                           var shaderOp = 'res = ';

                           var precNames = [gluShaderUtil.precision.PRECISION_LOWP,
                                            gluShaderUtil.precision.PRECISION_MEDIUMP,
                                            gluShaderUtil.precision.PRECISION_HIGHP];
                           // Setup shader data info.
                           shaderSpec.numInputs = 0;
                           shaderSpec.precision = isBoolCase ? undefined : precNames[precId];
                           shaderSpec.output = outDataType;
                           shaderSpec.resultScale = funcInfo.resultScale;
                           shaderSpec.resultBias = funcInfo.resultBias;
                           shaderSpec.referenceScale = funcInfo.referenceScale;
                           shaderSpec.referenceBias = funcInfo.referenceBias;

                           if (funcInfo.type == es3fShaderOperatorTests.OperationType.OPERATOR) {
                               if (isUnaryOp && funcInfo.isUnaryPrefix)
                                   shaderOp += shaderFuncName;
                           } else if (funcInfo.type == es3fShaderOperatorTests.OperationType.FUNCTION)
                               shaderOp += shaderFuncName + '(';
                           else // SIDE_EFFECT_OPERATOR
                               shaderOp += 'in0;\n\t';

                           for (var inputNdx = 0; inputNdx < funcInfo.inputs.length; inputNdx++) {
                               var prevNdx = inputNdx > 0 ? inputNdx - 1 : funcInfo.inputs.length - 1;
                               var prevValue = funcInfo.inputs[prevNdx];
                               var value = funcInfo.inputs[inputNdx];

                               if (value.valueType == es3fShaderOperatorTests.ValueType.NONE)
                                   continue; // Skip unused input.

                               var prevInScalarSize = es3fShaderOperatorTests.isScalarType(prevValue.valueType) ? 1 : inScalarSize;
                               var prevInDataType = es3fShaderOperatorTests.isFloatType(prevValue.valueType) ? s_floatTypes[prevInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isIntType(prevValue.valueType) ? s_intTypes[prevInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isUintType(prevValue.valueType) ? s_uintTypes[prevInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isBoolType(prevValue.valueType) ? s_boolTypes[prevInScalarSize - 1] :
                                                                   undefined;

                               var curInScalarSize = es3fShaderOperatorTests.isScalarType(value.valueType) ? 1 : inScalarSize;
                               var curInDataType = es3fShaderOperatorTests.isFloatType(value.valueType) ? s_floatTypes[curInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isIntType(value.valueType) ? s_intTypes[curInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isUintType(value.valueType) ? s_uintTypes[curInScalarSize - 1] :
                                                                   es3fShaderOperatorTests.isBoolType(value.valueType) ? s_boolTypes[curInScalarSize - 1] :
                                                                   undefined;

                               // Write input type(s) to case description and name.

                               if (inputNdx > 0)
                                   desc += ', ';

                               desc += gluShaderUtil.getDataTypeName(curInDataType);

                               if (inputNdx == 0 || prevInDataType != curInDataType) // \note Only write input type to case name if different from previous input type (avoid overly long names).
                                   name += gluShaderUtil.getDataTypeName(curInDataType) + '_';

                               // Generate op input source.

                               if (funcInfo.type == es3fShaderOperatorTests.OperationType.OPERATOR || funcInfo.type == es3fShaderOperatorTests.OperationType.FUNCTION) {
                                   if (inputNdx != 0) {
                                       if (funcInfo.type == es3fShaderOperatorTests.OperationType.OPERATOR && !isUnaryOp)
                                           shaderOp += ' ' + shaderFuncName + ' ';
                                       else
                                           shaderOp += ', ';
                                   }

                                   shaderOp += 'in' + inputNdx.toString(10);

                                   if (funcInfo.type == es3fShaderOperatorTests.OperationType.OPERATOR && isUnaryOp && !funcInfo.isUnaryPrefix)
                                       shaderOp += shaderFuncName;
                               } else{
                                   if (inputNdx != 0 || (isUnaryOp && funcInfo.isUnaryPrefix))
                                       shaderOp += (isUnaryOp ? '' : ' ') + shaderFuncName + (isUnaryOp ? '' : ' ');

                                   shaderOp += inputNdx == 0 ? 'res' : 'in' + inputNdx.toString(10); // \note in0 has already been assigned to res, so start from in1.

                                   if (isUnaryOp && !funcInfo.isUnaryPrefix)
                                       shaderOp += shaderFuncName;
                               }

                               // Fill in shader info.
                               shaderSpec.inputs[shaderSpec.numInputs++] = new es3fShaderOperatorTests.ShaderValue(curInDataType, value.rangeMin, value.rangeMax);
                           }

                           if (funcInfo.type == es3fShaderOperatorTests.OperationType.FUNCTION)
                               shaderOp += ')';

                           shaderOp += ';';

                           desc += ').';
                           name += shaderTypeName;

                           // Create the test case.
                           innerGroup.addChild(new es3fShaderOperatorTests.ShaderOperatorCase(name, desc, isVertexCase, evalFunc, shaderOp, shaderSpec));
                       }
                   }
               }
           }
       }
   }

   // The ?: selection operator.

   var s_selectionInfo = [
       gluShaderUtil.DataType.FLOAT,
       gluShaderUtil.DataType.FLOAT_VEC2,
       gluShaderUtil.DataType.FLOAT_VEC3,
       gluShaderUtil.DataType.FLOAT_VEC4,
       gluShaderUtil.DataType.INT,
       gluShaderUtil.DataType.INT_VEC2,
       gluShaderUtil.DataType.INT_VEC3,
       gluShaderUtil.DataType.INT_VEC4,
       gluShaderUtil.DataType.UINT,
       gluShaderUtil.DataType.UINT_VEC2,
       gluShaderUtil.DataType.UINT_VEC3,
       gluShaderUtil.DataType.UINT_VEC4,
       gluShaderUtil.DataType.BOOL,
       gluShaderUtil.DataType.BOOL_VEC2,
       gluShaderUtil.DataType.BOOL_VEC3,
       gluShaderUtil.DataType.BOOL_VEC4
   ];

   var selectionEvalFuncsFloat = es3fShaderOperatorTests.selectionFuncs(gluShaderUtil.DataType.FLOAT);
   var selectionEvalFuncsInt = es3fShaderOperatorTests.selectionFuncs(gluShaderUtil.DataType.INT);
   var selectionEvalFuncsUint = es3fShaderOperatorTests.selectionFuncs(gluShaderUtil.DataType.UINT);
   var selectionEvalFuncsBool = es3fShaderOperatorTests.selectionFuncs(gluShaderUtil.DataType.BOOL);

   var selectionGroup = new tcuTestCase.DeqpTest('selection', 'Selection operator tests');
   this.addChild(selectionGroup);

   for (var typeNdx = 0; typeNdx < s_selectionInfo.length; typeNdx++) {
       var curType = s_selectionInfo[typeNdx];
       var scalarSize = gluShaderUtil.getDataTypeScalarSize(curType);
       var isBoolCase = gluShaderUtil.isDataTypeBoolOrBVec(curType);
       var isFloatCase = gluShaderUtil.isDataTypeFloatOrVec(curType);
       var isIntCase = gluShaderUtil.isDataTypeIntOrIVec(curType);
       var isUintCase = gluShaderUtil.isDataTypeUintOrUVec(curType);
       var dataTypeStr = gluShaderUtil.getDataTypeName(curType);

       var evalFuncs = selectionEvalFuncsFloat;
       if (isBoolCase)
           evalFuncs = selectionEvalFuncsBool;
       else if (isIntCase)
           evalFuncs = selectionEvalFuncsInt;
       else if (isUintCase)
           evalFuncs = selectionEvalFuncsUint;

       var evalFunc = evalFuncs[scalarSize];

       for (var prec in gluShaderUtil.precision) {
           var precision = gluShaderUtil.precision[prec];
           if (isBoolCase && precision != gluShaderUtil.precision.PRECISION_MEDIUMP) // Use mediump interpolators for booleans.
               continue;

           var precisionStr = gluShaderUtil.getPrecisionName(precision);
           var precisionPrefix = isBoolCase ? '' : (precisionStr + '_');

           for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
               var shaderType = s_shaderTypes[shaderTypeNdx];
               var shaderSpec = new es3fShaderOperatorTests.ShaderDataSpec();
               var shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
               var isVertexCase = shaderType == gluShaderProgram.shaderType.VERTEX;

               var name = precisionPrefix + dataTypeStr + '_' + shaderTypeName;

               shaderSpec.numInputs = 3;
               shaderSpec.precision = isBoolCase ? undefined : precision;
               shaderSpec.output = curType;
               shaderSpec.resultScale = isBoolCase ? f(1.0) : isFloatCase ? f(0.5) : isUintCase ? f(0.5) : f(0.1);
               shaderSpec.resultBias = isBoolCase ? f(0.0) : isFloatCase ? f(0.5) : isUintCase ? f(0.0) : f(0.5);
               shaderSpec.referenceScale = shaderSpec.resultScale;
               shaderSpec.referenceBias = shaderSpec.resultBias;

               var rangeMin = isBoolCase ? -1.0 : isFloatCase ? -1.0 : isUintCase ? 0.0 : -5.0;
               var rangeMax = isBoolCase ? 1.0 : isFloatCase ? 1.0 : isUintCase ? 2.0 : 5.0;

               shaderSpec.inputs[0] = new es3fShaderOperatorTests.ShaderValue(gluShaderUtil.DataType.BOOL, f(-1.0), f(1.0));
               shaderSpec.inputs[1] = new es3fShaderOperatorTests.ShaderValue(curType, f(rangeMin), f(rangeMax));
               shaderSpec.inputs[2] = new es3fShaderOperatorTests.ShaderValue(curType, f(rangeMin), f(rangeMax));

               selectionGroup.addChild(new es3fShaderOperatorTests.ShaderOperatorCase(name, '', isVertexCase, evalFunc, 'res = in0 ? in1 : in2;', shaderSpec));
           }
       }
   }

   // The sequence operator (comma).
   /** @type {tcuTestCase.DeqpTest} */ var sequenceGroup = new tcuTestCase.DeqpTest('sequence', 'sequence');
   this.addChild(sequenceGroup);

   /** @type {tcuTestCase.DeqpTest} */ var sequenceNoSideEffGroup = new tcuTestCase.DeqpTest('no_side_effects', 'Sequence tests without side-effects');
   /** @type {tcuTestCase.DeqpTest} */ var sequenceSideEffGroup = new tcuTestCase.DeqpTest('side_effects', 'Sequence tests with side-effects');
   sequenceGroup.addChild(sequenceNoSideEffGroup);
   sequenceGroup.addChild(sequenceSideEffGroup);

   /**
    * @struct
    * @constructor
    * @param {boolean} containsSideEffects
    * @param {string} caseName
    * @param {string} expressionStr
    * @param {number} numInputs
    * @param {Array<gluShaderUtil.DataType>} inputTypes
    * @param {gluShaderUtil.DataType} resultType
    * @param {glsShaderRenderCase.ShaderEvalFunc} evalFunc
    */
    var SequenceCase = function(containsSideEffects, caseName, expressionStr, numInputs, inputTypes, resultType, evalFunc) {
        /** @type {boolean} */ this.containsSideEffects = containsSideEffects;
        /** @type {string} */ this.caseName = caseName;
        /** @type {string} */ this.expressionStr = expressionStr;
        /** @type {number} */ this.numInputs = numInputs;
        /** @type {Array<gluShaderUtil.DataType>} */ this.inputTypes = inputTypes;
        /** @type {gluShaderUtil.DataType} */ this.resultType = resultType;
        /** @type {glsShaderRenderCase.ShaderEvalFunc} */ this.evalFunc = evalFunc;
   };

   /** @type {Array<SequenceCase>} */ var s_sequenceCases = [
       new SequenceCase(false, 'vec4', 'in0, in2 + in1, in1 + in0', 3, [gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.FLOAT_VEC4], gluShaderUtil.DataType.FLOAT_VEC4, es3fShaderOperatorTests.evalSequenceNoSideEffCase0),
       new SequenceCase(false, 'float_uint', 'in0 + in2, in1 + in1', 3, [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.UINT, gluShaderUtil.DataType.FLOAT], gluShaderUtil.DataType.UINT, es3fShaderOperatorTests.evalSequenceNoSideEffCase1),
       new SequenceCase(false, 'bool_vec2', 'in0 && in1, in0, ivec2(vec2(in0) + in2)', 3, [gluShaderUtil.DataType.BOOL, gluShaderUtil.DataType.BOOL, gluShaderUtil.DataType.FLOAT_VEC2], gluShaderUtil.DataType.INT_VEC2, es3fShaderOperatorTests.evalSequenceNoSideEffCase2),
       new SequenceCase(false, 'vec4_ivec4_bvec4', 'in0 + vec4(in1), in2, in1', 3, [gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.INT_VEC4, gluShaderUtil.DataType.BOOL_VEC4], gluShaderUtil.DataType.INT_VEC4, es3fShaderOperatorTests.evalSequenceNoSideEffCase3),

       new SequenceCase(true, 'vec4', 'in0++, in1 = in0 + in2, in2 = in1', 3, [gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.FLOAT_VEC4], gluShaderUtil.DataType.FLOAT_VEC4, es3fShaderOperatorTests.evalSequenceSideEffCase0),
       new SequenceCase(true, 'float_uint', 'in1++, in0 = float(in1), in1 = uint(in0 + in2)', 3, [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.UINT, gluShaderUtil.DataType.FLOAT], gluShaderUtil.DataType.UINT, es3fShaderOperatorTests.evalSequenceSideEffCase1),
       new SequenceCase(true, 'bool_vec2', 'in1 = in0, in2++, in2 = in2 + vec2(in1), ivec2(in2)', 3, [gluShaderUtil.DataType.BOOL, gluShaderUtil.DataType.BOOL, gluShaderUtil.DataType.FLOAT_VEC2], gluShaderUtil.DataType.INT_VEC2, es3fShaderOperatorTests.evalSequenceSideEffCase2),
       new SequenceCase(true, 'vec4_ivec4_bvec4', 'in0 = in0 + vec4(in2), in1 = in1 + ivec4(in0), in1++', 3, [gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.INT_VEC4, gluShaderUtil.DataType.BOOL_VEC4], gluShaderUtil.DataType.INT_VEC4, es3fShaderOperatorTests.evalSequenceSideEffCase3)
   ];

   for (var caseNdx = 0; caseNdx < s_sequenceCases.length; caseNdx++) {
       for (var precision in gluShaderUtil.precision) {
           for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
               /** @type {gluShaderProgram.shaderType} */ var shaderType = s_shaderTypes[shaderTypeNdx];
               /** @type {es3fShaderOperatorTests.ShaderDataSpec} */ var shaderSpec = new es3fShaderOperatorTests.ShaderDataSpec();
               /** @type {string} */ var shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
               /** @type {boolean} */ var isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;

               /** @type {string} */ var name = gluShaderUtil.getPrecisionName(gluShaderUtil.precision[precision]) + '_' + s_sequenceCases[caseNdx].caseName + '_' + shaderTypeName;

               shaderSpec.numInputs = s_sequenceCases[caseNdx].numInputs;
               shaderSpec.precision = gluShaderUtil.precision[precision];
               shaderSpec.output = s_sequenceCases[caseNdx].resultType;
               shaderSpec.resultScale = f(0.5);
               shaderSpec.resultBias = f(0.0);
               shaderSpec.referenceScale = shaderSpec.resultScale;
               shaderSpec.referenceBias = shaderSpec.resultBias;

               for (var inputNdx = 0; inputNdx < s_sequenceCases[caseNdx].numInputs; inputNdx++) {
                   /** @type {gluShaderUtil.DataType} */ var type = s_sequenceCases[caseNdx].inputTypes[inputNdx];
                   /** @type {es3fShaderOperatorTests.FloatScalar} */ var rangeMin = gluShaderUtil.isDataTypeFloatOrVec(type) ?
                       f(-0.5) : gluShaderUtil.isDataTypeIntOrIVec(type) ?
                       f(-2.0) : gluShaderUtil.isDataTypeUintOrUVec(type) ?
                       f(0.0) : f(-1.0);

                   /** @type {es3fShaderOperatorTests.FloatScalar} */ var rangeMax = gluShaderUtil.isDataTypeFloatOrVec(type) ?
                       f(0.5) : gluShaderUtil.isDataTypeIntOrIVec(type) ?
                       f(2.0) : gluShaderUtil.isDataTypeUintOrUVec(type) ?
                       f(2.0) : f(1.0);

                   shaderSpec.inputs[inputNdx] = new es3fShaderOperatorTests.ShaderValue(type, rangeMin, rangeMax);
               }

               /** @type {string} */ var expression = 'res = (' + s_sequenceCases[caseNdx].expressionStr + ');';

               if (s_sequenceCases[caseNdx].containsSideEffects)
                   sequenceSideEffGroup.addChild(new es3fShaderOperatorTests.ShaderOperatorCase(name, '', isVertexCase, s_sequenceCases[caseNdx].evalFunc, expression, shaderSpec));
               else
                   sequenceNoSideEffGroup.addChild(new es3fShaderOperatorTests.ShaderOperatorCase(name, '', isVertexCase, s_sequenceCases[caseNdx].evalFunc, expression, shaderSpec));
           }
       }
   }

};

/**
* Run test
* @param {WebGL2RenderingContext} context
*/
es3fShaderOperatorTests.run = function(context, range) {
   gl = context;

   const canvas = gl.canvas;
   canvas.width = canvasWH;
   canvas.height = canvasWH;

   //Set up Test Root parameters
   var state = tcuTestCase.runner;
   state.setRoot(new es3fShaderOperatorTests.ShaderOperatorTests());

   //Set up name and description of this test series.
   setCurrentTestName(state.testCases.fullName());
   description(state.testCases.getDescription());

   try {
       if (range)
           state.setRange(range);
       //Run test cases
       tcuTestCase.runTestCases();
   }
   catch (err) {
       testFailedOptions('Failed to es3fShaderOperatorTests.run tests', false);
       tcuTestCase.runner.terminate();
   }
};

});