dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fDefaultVertexAttributeTests.js

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the 'License');
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an 'AS IS' BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 'use strict';
  22 goog.provide('functional.gles3.es3fDefaultVertexAttributeTests');
  23 goog.require('framework.common.tcuLogImage');
  24 goog.require('framework.common.tcuSurface');
  25 goog.require('framework.common.tcuTestCase');
  26 goog.require('framework.delibs.debase.deMath');
  27 goog.require('framework.opengl.gluShaderProgram');
  28 goog.require('framework.opengl.gluShaderUtil');
  29
  30 goog.scope(function() {
  31 var es3fDefaultVertexAttributeTests = functional.gles3.es3fDefaultVertexAttributeTests;
  32 var tcuTestCase = framework.common.tcuTestCase;
  33 var tcuSurface = framework.common.tcuSurface;
  34 var deMath = framework.delibs.debase.deMath;
  35 var gluShaderProgram = framework.opengl.gluShaderProgram;
  36 var gluShaderUtil = framework.opengl.gluShaderUtil;
  37 var tcuLogImage = framework.common.tcuLogImage;
  38
  39 var setParentClass = function(child, parent) {
  40     child.prototype = Object.create(parent.prototype);
  41     child.prototype.constructor = child;
  42 };
  43
  44 /**
  45  * @constructor
  46  */
  47 es3fDefaultVertexAttributeTests.LoaderVertexAttrib1f = function() {
  48     this.caseName = 'vertex_attrib_1f';
  49     this.name = 'VertexAttrib1f';
  50     this.signed = true;
  51     this.load = function(index, value) {
  52         gl.vertexAttrib1f(index, value[0]);
  53         return [value[0], 0, 0, 1];
  54     };
  55 };
  56
  57 /**
  58  * @constructor
  59  */
  60 es3fDefaultVertexAttributeTests.LoaderVertexAttrib2f = function() {
  61     this.caseName = 'vertex_attrib_2f';
  62     this.name = 'VertexAttrib2f';
  63     this.signed = true;
  64     this.load = function(index, value) {
  65         gl.vertexAttrib2f(index, value[0], value[1]);
  66         return [value[0], value[1], 0, 1];
  67     };
  68 };
  69
  70 /**
  71  * @constructor
  72  */
  73 es3fDefaultVertexAttributeTests.LoaderVertexAttrib3f = function() {
  74     this.caseName = 'vertex_attrib_3f';
  75     this.name = 'VertexAttrib3f';
  76     this.signed = true;
  77     this.load = function(index, value) {
  78         gl.vertexAttrib3f(index, value[0], value[1], value[2]);
  79         return [value[0], value[1], value[2], 1];
  80     };
  81 };
  82
  83 /**
  84  * @constructor
  85  */
  86 es3fDefaultVertexAttributeTests.LoaderVertexAttrib4f = function() {
  87     this.caseName = 'vertex_attrib_4f';
  88     this.name = 'VertexAttrib4f';
  89     this.signed = true;
  90     this.load = function(index, value) {
  91         gl.vertexAttrib4f(index, value[0], value[1], value[2], value[3]);
  92         return [value[0], value[1], value[2], value[3]];
  93     };
  94 };
  95
  96 /**
  97  * @constructor
  98  */
  99 es3fDefaultVertexAttributeTests.LoaderVertexAttrib1fv = function() {
 100     this.caseName = 'vertex_attrib_1fv';
 101     this.name = 'VertexAttrib1fv';
 102     this.signed = true;
 103     this.load = function(index, value) {
 104         gl.vertexAttrib1fv(index, value.slice(0, 1));
 105         return [value[0], 0, 0, 1];
 106     };
 107 };
 108
 109 /**
 110  * @constructor
 111  */
 112 es3fDefaultVertexAttributeTests.LoaderVertexAttrib2fv = function() {
 113     this.caseName = 'vertex_attrib_2fv';
 114     this.name = 'VertexAttrib2fv';
 115     this.signed = true;
 116     this.load = function(index, value) {
 117         gl.vertexAttrib2fv(index, value.slice(0, 2));
 118         return [value[0], value[1], 0, 1];
 119     };
 120 };
 121
 122 /**
 123  * @constructor
 124  */
 125 es3fDefaultVertexAttributeTests.LoaderVertexAttrib3fv = function() {
 126     this.caseName = 'vertex_attrib_3fv';
 127     this.name = 'VertexAttrib3fv';
 128     this.signed = true;
 129     this.load = function(index, value) {
 130         gl.vertexAttrib3fv(index, value.slice(0, 3));
 131         return [value[0], value[1], value[2], 1];
 132     };
 133 };
 134
 135 /**
 136  * @constructor
 137  */
 138 es3fDefaultVertexAttributeTests.LoaderVertexAttrib4fv = function() {
 139     this.caseName = 'vertex_attrib_4fv';
 140     this.name = 'VertexAttrib4fv';
 141     this.signed = true;
 142     this.load = function(index, value) {
 143         gl.vertexAttrib4fv(index, value.slice(0, 4));
 144         return [value[0], value[1], value[2], value[3]];
 145     };
 146 };
 147
 148 /**
 149  * @constructor
 150  */
 151 es3fDefaultVertexAttributeTests.LoaderVertexAttribI4i = function() {
 152     this.caseName = 'vertex_attrib_4i';
 153     this.name = 'VertexAttribI4i';
 154     this.signed = true;
 155     this.load = function(index, value) {
 156         var v = new Int32Array(value);
 157         gl.vertexAttribI4i(index, v[0], v[1], v[2], v[3]);
 158         return [v[0], v[1], v[2], v[3]];
 159     };
 160 };
 161
 162 /**
 163  * @constructor
 164  */
 165 es3fDefaultVertexAttributeTests.LoaderVertexAttribI4iv = function() {
 166     this.caseName = 'vertex_attrib_4iv';
 167     this.name = 'VertexAttribI4iv';
 168     this.signed = true;
 169     this.load = function(index, value) {
 170         var v = new Int32Array(value);
 171         gl.vertexAttribI4iv(index, v);
 172         return [v[0], v[1], v[2], v[3]];
 173     };
 174 };
 175
 176 /**
 177  * @constructor
 178  */
 179 es3fDefaultVertexAttributeTests.LoaderVertexAttribI4ui = function() {
 180     this.caseName = 'vertex_attrib_4ui';
 181     this.name = 'VertexAttribI4ui';
 182     this.signed = false;
 183     this.load = function(index, value) {
 184         var v = new Uint32Array(value);
 185         gl.vertexAttribI4ui(index, v[0], v[1], v[2], v[3]);
 186         return [v[0], v[1], v[2], v[3]];
 187     };
 188 };
 189
 190 /**
 191  * @constructor
 192  */
 193 es3fDefaultVertexAttributeTests.LoaderVertexAttribI4uiv = function() {
 194     this.caseName = 'vertex_attrib_4uiv';
 195     this.name = 'VertexAttribI4uiv';
 196     this.signed = false;
 197     this.load = function(index, value) {
 198         var v = new Uint32Array(value);
 199         gl.vertexAttribI4uiv(index, v);
 200         return [v[0], v[1], v[2], v[3]];
 201     };
 202 };
 203
 204 /** @const */ var RENDER_SIZE = 32;
 205 /** @const */ var s_valueRange = 10;
 206 /** @const */ var s_passThroughFragmentShaderSource = '#version 300 es\n' +
 207                                                         'layout(location = 0) out mediump vec4 fragColor;\n' +
 208                                                         'in mediump vec4 v_color;\n' +
 209                                                         'void main (void)\n' +
 210                                                         '{\n' +
 211                                                         ' fragColor = v_color;\n' +
 212                                                         '}\n';
 213
 214 /**
 215  * @constructor
 216  * @extends {tcuTestCase.DeqpTest}
 217  */
 218 es3fDefaultVertexAttributeTests.AttributeCase = function(loaderType, dataType) {
 219     var loader = new loaderType();
 220     var name = loader.caseName;
 221     var description = 'Test ' + loader.name;
 222     tcuTestCase.DeqpTest.call(this, name, description);
 223     this.m_funcName = loader.name;
 224     this.m_useNegativeValues = loader.signed;
 225     this.m_dataType = dataType;
 226     this.m_allIterationsPassed = true;
 227     this.m_loader = loader;
 228     this.m_iteration = 0;
 229 };
 230
 231 setParentClass(es3fDefaultVertexAttributeTests.AttributeCase, tcuTestCase.DeqpTest);
 232
 233 es3fDefaultVertexAttributeTests.AttributeCase.prototype.init = function() {
 234     // log test info
 235
 236     var maxRange = s_valueRange;
 237     var minRange = (this.m_useNegativeValues) ? (-maxRange) : (0.0);
 238
 239     bufferedLogToConsole(
 240         'Loading attribute values using ' + this.m_funcName + '\n' +
 241         'Attribute type: ' + gluShaderUtil.getDataTypeName(this.m_dataType) + '\n' +
 242         'Attribute value range: [' + minRange + ', ' + maxRange + ']');
 243
 244     // gen shader and base quad
 245
 246     this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(this.genVertexSource(), s_passThroughFragmentShaderSource));
 247     if (!this.m_program.isOk())
 248         testFailedOptions('could not build program', true);
 249
 250     var fullscreenQuad = [
 251          1.0, 1.0, 0.0, 1.0,
 252          1.0, -1.0, 0.0, 1.0,
 253         -1.0, 1.0, 0.0, 1.0,
 254         -1.0, -1.0, 0.0, 1.0
 255     ];
 256
 257     this.m_bufID = gl.createBuffer();
 258     gl.bindBuffer(gl.ARRAY_BUFFER, this.m_bufID);
 259     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(fullscreenQuad), gl.STATIC_DRAW);
 260 };
 261
 262 es3fDefaultVertexAttributeTests.AttributeCase.prototype.deinit = function() {
 263     this.m_loader = null;
 264
 265     gl.useProgram(null);
 266     this.m_program = null;
 267
 268     if (this.m_bufID) {
 269         gl.deleteBuffer(this.m_bufID);
 270         this.m_bufID = null;
 271     }
 272 };
 273
 274 es3fDefaultVertexAttributeTests.AttributeCase.prototype.iterate = function() {
 275     var testValues = [
 276         [0.0, 0.5, 0.2, 1.0],
 277         [0.1, 0.7, 1.0, 0.6],
 278         [0.4, 0.2, 0.0, 0.5],
 279         [0.5, 0.0, 0.9, 0.1],
 280         [0.6, 0.2, 0.2, 0.9],
 281         [0.9, 1.0, 0.0, 0.0],
 282         [1.0, 0.5, 0.3, 0.8]
 283     ];
 284
 285     bufferedLogToConsole('Iteration ' + (this.m_iteration + 1) + '/' + testValues.length);
 286
 287     var testValue = this.m_useNegativeValues ?
 288         deMath.subScalar(deMath.scale(testValues[this.m_iteration], 2), 1) :
 289         deMath.scale(testValues[this.m_iteration], s_valueRange);
 290
 291     if (!this.renderWithValue(testValue))
 292         this.m_allIterationsPassed = false;
 293
 294     // continue
 295
 296     if (++this.m_iteration < testValues.length)
 297         return tcuTestCase.IterateResult.CONTINUE;
 298
 299     if (this.m_allIterationsPassed)
 300         testPassed();
 301     else
 302         testFailed('Got unexpected values');
 303
 304     return tcuTestCase.IterateResult.STOP;
 305 };
 306
 307 es3fDefaultVertexAttributeTests.AttributeCase.prototype.genVertexSource = function() {
 308     var vectorSize = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.isDataTypeVector(this.m_dataType)) ? (gluShaderUtil.getDataTypeScalarSize(this.m_dataType)) : (-1);
 309     var vectorType = gluShaderUtil.getDataTypeName((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeVector(gluShaderUtil.DataType.FLOAT, vectorSize)) : (gluShaderUtil.isDataTypeVector(this.m_dataType)) ? (gluShaderUtil.getDataTypeVector(gluShaderUtil.DataType.FLOAT, vectorSize)) : (gluShaderUtil.DataType.FLOAT));
 310     var components = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.getDataTypeScalarSize(this.m_dataType));
 311
 312     var buf = '#version 300 es\n' +
 313             'in highp vec4 a_position;\n' +
 314             'in highp ' + gluShaderUtil.getDataTypeName(this.m_dataType) + ' a_value;\n' +
 315             'out highp vec4 v_color;\n' +
 316             'void main (void)\n' +
 317             '{\n' +
 318             ' gl_Position = a_position;\n' +
 319             '\n';
 320
 321     buf += ' highp ' + vectorType + ' normalizedValue = ' + ((gluShaderUtil.getDataTypeScalarType(this.m_dataType) == gluShaderUtil.DataType.FLOAT) ? ('') : (vectorType)) + '(a_value' + ((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? ('[1]') : ('')) + ') / float(' + s_valueRange + ');\n';
 322
 323     if (this.m_useNegativeValues)
 324         buf += ' highp ' + vectorType + ' positiveNormalizedValue = (normalizedValue + ' + vectorType + '(1.0)) / 2.0;\n';
 325     else
 326         buf += ' highp ' + vectorType + ' positiveNormalizedValue = normalizedValue;\n';
 327
 328     if (components == 1)
 329         buf += ' v_color = vec4(positiveNormalizedValue, 0.0, 0.0, 1.0);\n';
 330     else if (components == 2)
 331         buf += ' v_color = vec4(positiveNormalizedValue.xy, 0.0, 1.0);\n';
 332     else if (components == 3)
 333         buf += ' v_color = vec4(positiveNormalizedValue.xyz, 1.0);\n';
 334     else if (components == 4)
 335         buf += ' v_color = vec4((positiveNormalizedValue.xy + positiveNormalizedValue.zz) / 2.0, positiveNormalizedValue.w, 1.0);\n';
 336     else
 337        throw new Error('Wrong component size: ' + components);
 338
 339     buf += '}\n';
 340
 341     return buf;
 342 };
 343
 344 es3fDefaultVertexAttributeTests.AttributeCase.prototype.renderWithValue = function(v) {
 345     var positionIndex = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
 346     var valueIndex = gl.getAttribLocation(this.m_program.getProgram(), 'a_value');
 347     var dest = new tcuSurface.Surface(RENDER_SIZE, RENDER_SIZE);
 348
 349     gl.clearColor(0.0, 0.0, 0.0, 0.0);
 350     gl.clear(gl.COLOR_BUFFER_BIT);
 351     gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
 352
 353     gl.bindBuffer(gl.ARRAY_BUFFER, this.m_bufID);
 354     gl.vertexAttribPointer(positionIndex, 4, gl.FLOAT, false, 0, 0);
 355     gl.enableVertexAttribArray(positionIndex);
 356
 357     // transfer test value. Load to the second column in the matrix case
 358     var loadedValue = this.m_loader.load((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (valueIndex + 1) : (valueIndex), v);
 359
 360     gl.useProgram(this.m_program.getProgram());
 361     gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
 362     gl.useProgram(null);
 363     // The original c++ test does not disable vertex attrib array, which is wrong.
 364     // On most drivers all tests pass because a_position is assigned location 0.
 365     // On MacOSX some tests fail because a_value is assigned location 0 and vertex
 366     // attrib array is left enabled and affects later tests.
 367     gl.disableVertexAttribArray(positionIndex);
 368     dest.readViewport(gl);
 369
 370     // check whole result is colored correctly
 371     return this.verifyUnicoloredBuffer(dest, this.computeColor(loadedValue));
 372 };
 373
 374 es3fDefaultVertexAttributeTests.AttributeCase.prototype.computeColor = function(value) {
 375     var normalizedValue = deMath.scale(value, 1 / s_valueRange);
 376     var positiveNormalizedValue = this.m_useNegativeValues ?
 377         deMath.scale(deMath.addScalar(normalizedValue, 1), 0.5) :
 378         normalizedValue;
 379     var components = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.getDataTypeScalarSize(this.m_dataType));
 380
 381     if (components == 1)
 382         return [positiveNormalizedValue[0], 0.0, 0.0, 1.0];
 383     else if (components == 2)
 384         return [positiveNormalizedValue[0], positiveNormalizedValue[1], 0.0, 1.0];
 385     else if (components == 3)
 386         return [positiveNormalizedValue[0], positiveNormalizedValue[1], positiveNormalizedValue[2], 1.0];
 387     else if (components == 4)
 388         return [(positiveNormalizedValue[0] + positiveNormalizedValue[2]) / 2.0, (positiveNormalizedValue[1] + positiveNormalizedValue[2]) / 2.0, positiveNormalizedValue[3], 1.0];
 389     else
 390        throw new Error('Wrong component size: ' + components);
 391 };
 392
 393 /**
 394  * @param {tcuSurface.Surface} scene
 395  * @param {Array<number>} refColor
 396  * @return {boolean}
 397  */
 398 es3fDefaultVertexAttributeTests.AttributeCase.prototype.verifyUnicoloredBuffer = function(scene, refColor) {
 399     var access = scene.getAccess();
 400     var errorMask = new tcuSurface.Surface(RENDER_SIZE, RENDER_SIZE);
 401     var colorThreshold = [6, 6, 6, 6];
 402     var error = false;
 403
 404     errorMask.getAccess().clear([0, 1, 0, 1]);
 405
 406     bufferedLogToConsole('Verifying rendered image. Expecting color ' + refColor + ', threshold ' + colorThreshold);
 407
 408     for (var y = 0; y < RENDER_SIZE; ++y)
 409     for (var x = 0; x < RENDER_SIZE; ++x) {
 410         var color = access.getPixel(x, y);
 411
 412         if (Math.abs(color[0] - refColor[0]) > colorThreshold[0] ||
 413             Math.abs(color[1] - refColor[1]) > colorThreshold[1] ||
 414             Math.abs(color[2] - refColor[2]) > colorThreshold[2]) {
 415
 416             // first error
 417             if (!error)
 418                 debug('Found invalid pixel(s). Pixel at (' + x + ', ' + y + ') color: ' + color);
 419
 420             error = true;
 421             errorMask.setPixel(x, y, [1, 0, 0, 1]);
 422         }
 423     }
 424
 425     if (!error)
 426         bufferedLogToConsole('Rendered image is valid.');
 427     else {
 428         tcuLogImage.logImage('Result', '', access);
 429         tcuLogImage.logImage('Error mask', '', errorMask.getAccess());
 430     }
 431
 432     return !error;
 433 };
 434
 435 /**
 436 * @constructor
 437 * @extends {tcuTestCase.DeqpTest}
 438 */
 439 es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests = function() {
 440     tcuTestCase.DeqpTest.call(this, 'default_vertex_attrib', 'Test default vertex attributes');
 441 };
 442
 443 es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
 444 es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype.constructor = es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests;
 445
 446 es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype.init = function() {
 447     var tests = this;
 448     var floatTargets = [
 449         ['float', gluShaderUtil.DataType.FLOAT, false],
 450         ['vec2', gluShaderUtil.DataType.FLOAT_VEC2, true],
 451         ['vec3', gluShaderUtil.DataType.FLOAT_VEC3, true],
 452         ['vec4', gluShaderUtil.DataType.FLOAT_VEC4, false],
 453         ['mat2', gluShaderUtil.DataType.FLOAT_MAT2, true],
 454         ['mat2x3', gluShaderUtil.DataType.FLOAT_MAT2X3, true],
 455         ['mat2x4', gluShaderUtil.DataType.FLOAT_MAT2X4, true],
 456         ['mat3', gluShaderUtil.DataType.FLOAT_MAT3, true],
 457         ['mat3x2', gluShaderUtil.DataType.FLOAT_MAT3X2, true],
 458         ['mat3x4', gluShaderUtil.DataType.FLOAT_MAT3X4, true],
 459         ['mat4', gluShaderUtil.DataType.FLOAT_MAT4, false],
 460         ['mat4x2', gluShaderUtil.DataType.FLOAT_MAT4X2, true],
 461         ['mat4x3', gluShaderUtil.DataType.FLOAT_MAT4X3, true]
 462     ];
 463
 464     floatTargets.forEach(function(elem) {
 465         var name = elem[0];
 466         var dataType = elem[1];
 467         var reduced = elem[2];
 468         var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
 469         tests.addChild(group);
 470         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib1f, dataType));
 471         if (!reduced) {
 472             group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib2f, dataType));
 473             group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib3f, dataType));
 474         }
 475         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib4f, dataType));
 476
 477         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib1fv, dataType));
 478         if (!reduced) {
 479             group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib2fv, dataType));
 480             group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib3fv, dataType));
 481         }
 482         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib4fv, dataType));
 483
 484     });
 485
 486     var intTargets = [
 487         ['int', gluShaderUtil.DataType.INT, false],
 488         ['ivec2', gluShaderUtil.DataType.INT_VEC2, true],
 489         ['ivec3', gluShaderUtil.DataType.INT_VEC3, true],
 490         ['ivec4', gluShaderUtil.DataType.INT_VEC4, false]
 491     ];
 492
 493    intTargets.forEach(function(elem) {
 494         var name = elem[0];
 495         var dataType = elem[1];
 496         var reduced = elem[2];
 497         var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
 498         tests.addChild(group);
 499         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4i, dataType));
 500         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4iv, dataType));
 501     });
 502
 503     var uintTargets = [
 504         ['uint', gluShaderUtil.DataType.UINT, false],
 505         ['uvec2', gluShaderUtil.DataType.UINT_VEC2, true],
 506         ['uvec3', gluShaderUtil.DataType.UINT_VEC3, true],
 507         ['uvec4', gluShaderUtil.DataType.UINT_VEC4, false]
 508     ];
 509
 510    uintTargets.forEach(function(elem) {
 511         var name = elem[0];
 512         var dataType = elem[1];
 513         var reduced = elem[2];
 514         var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
 515         tests.addChild(group);
 516         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4ui, dataType));
 517         group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4uiv, dataType));
 518     });
 519
 520 };
 521
 522 /**
 523 * Run test
 524 * @param {WebGL2RenderingContext} context
 525 */
 526 es3fDefaultVertexAttributeTests.run = function(context) {
 527     gl = context;
 528     //Set up Test Root parameters
 529     var state = tcuTestCase.runner;
 530     state.setRoot(new es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests());
 531
 532     //Set up name and description of this test series.
 533     setCurrentTestName(state.testCases.fullName());
 534     description(state.testCases.getDescription());
 535
 536     try {
 537         //Run test cases
 538         tcuTestCase.runTestCases();
 539     }
 540     catch (err) {
 541         testFailedOptions('Failed to es3fDefaultVertexAttributeTests.run tests', false);
 542         tcuTestCase.runner.terminate();
 543     }
 544 };
 545
 546 });