dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.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.es3fUniformBlockTests');
  23 goog.require('framework.common.tcuTestCase');
  24 goog.require('framework.delibs.debase.deMath');
  25 goog.require('framework.delibs.debase.deRandom');
  26 goog.require('framework.opengl.gluShaderUtil');
  27 goog.require('modules.shared.glsRandomUniformBlockCase');
  28 goog.require('modules.shared.glsUniformBlockCase');
  29
  30 goog.scope(function() {
  31
  32     var es3fUniformBlockTests = functional.gles3.es3fUniformBlockTests;
  33     var gluShaderUtil = framework.opengl.gluShaderUtil;
  34     var glsUniformBlockCase = modules.shared.glsUniformBlockCase;
  35     var glsRandomUniformBlockCase = modules.shared.glsRandomUniformBlockCase;
  36     var tcuTestCase = framework.common.tcuTestCase;
  37     var deMath = framework.delibs.debase.deMath;
  38     var deRandom = framework.delibs.debase.deRandom;
  39
  40     /**
  41      * es3fUniformBlockTests.createRandomCaseGroup
  42      * @param {tcuTestCase.DeqpTest} parentGroup
  43      * @param {string} groupName
  44      * @param {string} description
  45      * @param {glsUniformBlockCase.BufferMode} bufferMode
  46      * @param {number} features
  47      * @param {number} numCases
  48      * @param {number} baseSeed
  49      */
  50     es3fUniformBlockTests.createRandomCaseGroup = function(parentGroup, groupName, description, bufferMode, features, numCases, baseSeed) {
  51         /** @type {tcuTestCase.DeqpTest} */
  52         var group = tcuTestCase.newTest(groupName, description);
  53         parentGroup.addChild(group);
  54
  55         baseSeed += deRandom.getBaseSeed();
  56
  57         for (var ndx = 0; ndx < numCases; ndx++)
  58             group.addChild(new glsRandomUniformBlockCase.RandomUniformBlockCase('' + ndx, '', bufferMode, features, ndx + baseSeed));
  59     };
  60
  61     /**
  62      * es3fUniformBlockTests.BlockBasicTypeCase constructor
  63      * @param {string} name The name of the test
  64      * @param {string} description The description of the test
  65      * @param {glsUniformBlockCase.VarType} type The type of the block
  66      * @param {number} layoutFlags
  67      * @param {number} numInstances
  68      * @constructor
  69      * @extends {glsUniformBlockCase.UniformBlockCase}
  70      */
  71     es3fUniformBlockTests.BlockBasicTypeCase = function(name, description, type, layoutFlags, numInstances) {
  72         glsUniformBlockCase.UniformBlockCase.call(this, name, description, glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK);
  73         /** @type {glsUniformBlockCase.UniformBlock}*/ var block = this.m_interface.allocBlock('Block');
  74         block.addUniform(new glsUniformBlockCase.Uniform('var', type, 0));
  75         block.setFlags(layoutFlags);
  76
  77         if (numInstances > 0) {
  78             block.setArraySize(numInstances);
  79             block.setInstanceName('block');
  80         }
  81     };
  82
  83     es3fUniformBlockTests.BlockBasicTypeCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
  84     es3fUniformBlockTests.BlockBasicTypeCase.prototype.constructor = es3fUniformBlockTests.BlockBasicTypeCase;
  85
  86     /**
  87      * es3fUniformBlockTests.createBlockBasicTypeCases
  88      * @param {tcuTestCase.DeqpTest} group
  89      * @param {string} name
  90      * @param {glsUniformBlockCase.VarType} type
  91      * @param {number} layoutFlags
  92      * @param {number=} numInstances
  93      */
  94     es3fUniformBlockTests.createBlockBasicTypeCases = function(group, name, type, layoutFlags, numInstances) {
  95         numInstances = (numInstances === undefined) ? 0 : numInstances;
  96         group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_vertex', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, numInstances));
  97         group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_fragment', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, numInstances));
  98
  99         //alert(group.spec[0].m_instance);
 100         if (!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 101             group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_both', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, numInstances));
 102     };
 103
 104     /**
 105      * es3fUniformBlockTests.BlockSingleStructCase constructor
 106      * @param {string} name The name of the test
 107      * @param {string} description The description of the test
 108      * @param {number} layoutFlags
 109      * @param {glsUniformBlockCase.BufferMode} bufferMode
 110      * @param {number} numInstances
 111      * @constructor
 112      * @extends {glsUniformBlockCase.UniformBlockCase}
 113      */
 114     es3fUniformBlockTests.BlockSingleStructCase = function(name, description, layoutFlags, bufferMode, numInstances) {
 115         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 116         this.m_layoutFlags = layoutFlags;
 117         this.m_numInstances = numInstances;
 118     };
 119
 120     es3fUniformBlockTests.BlockSingleStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 121     es3fUniformBlockTests.BlockSingleStructCase.prototype.constructor = es3fUniformBlockTests.BlockSingleStructCase;
 122
 123     es3fUniformBlockTests.BlockSingleStructCase.prototype.init = function() {
 124         /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S');
 125         typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); // First member is unused.
 126         typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4));
 127         typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH));
 128
 129         /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block');
 130         block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0));
 131         block.setFlags(this.m_layoutFlags);
 132
 133         if (this.m_numInstances > 0) {
 134             block.setInstanceName('block');
 135             block.setArraySize(this.m_numInstances);
 136         }
 137     };
 138
 139     /**
 140      * es3fUniformBlockTests.BlockSingleStructArrayCase constructor
 141      * @param {string} name The name of the test
 142      * @param {string} description The description of the test
 143      * @param {number} layoutFlags
 144      * @param {glsUniformBlockCase.BufferMode} bufferMode
 145      * @param {number} numInstances
 146      * @constructor
 147      * @extends {glsUniformBlockCase.UniformBlockCase}
 148      */
 149     es3fUniformBlockTests.BlockSingleStructArrayCase = function(name, description, layoutFlags, bufferMode, numInstances) {
 150         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 151         this.m_layoutFlags = layoutFlags;
 152         this.m_numInstances = numInstances;
 153     };
 154
 155     es3fUniformBlockTests.BlockSingleStructArrayCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 156     es3fUniformBlockTests.BlockSingleStructArrayCase.prototype.constructor = es3fUniformBlockTests.BlockSingleStructArrayCase;
 157
 158     es3fUniformBlockTests.BlockSingleStructArrayCase.prototype.init = function() {
 159         /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S');
 160         typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); // First member is unused.
 161         typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4));
 162         typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH));
 163
 164         /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block');
 165         block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_LOW)));
 166         block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeS), 3)));
 167         block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)));
 168         block.setFlags(this.m_layoutFlags);
 169
 170         if (this.m_numInstances > 0) {
 171             block.setInstanceName('block');
 172             block.setArraySize(this.m_numInstances);
 173         }
 174     };
 175
 176     /**
 177      * es3fUniformBlockTests.BlockSingleNestedStructCase constructor
 178      * @param {string} name The name of the test
 179      * @param {string} description The description of the test
 180      * @param {number} layoutFlags
 181      * @param {glsUniformBlockCase.BufferMode} bufferMode
 182      * @param {number} numInstances
 183      * @constructor
 184      * @extends {glsUniformBlockCase.UniformBlockCase}
 185      */
 186     es3fUniformBlockTests.BlockSingleNestedStructCase = function(name, description, layoutFlags, bufferMode, numInstances) {
 187         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 188         this.m_layoutFlags = layoutFlags;
 189         this.m_numInstances = numInstances;
 190     };
 191
 192     es3fUniformBlockTests.BlockSingleNestedStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 193     es3fUniformBlockTests.BlockSingleNestedStructCase.prototype.constructor = es3fUniformBlockTests.BlockSingleNestedStructCase;
 194
 195     es3fUniformBlockTests.BlockSingleNestedStructCase.prototype.init = function() {
 196         /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S');
 197         typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH));
 198         typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4));
 199         typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
 200
 201         /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T');
 202         typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM));
 203         typeT.addMember('b', glsUniformBlockCase.newVarTypeStruct(typeS));
 204
 205         /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block');
 206         block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0));
 207         block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 208         block.addUniform(new glsUniformBlockCase.Uniform('t', glsUniformBlockCase.newVarTypeStruct(typeT), 0));
 209         block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), 0));
 210         block.setFlags(this.m_layoutFlags);
 211
 212         if (this.m_numInstances > 0) {
 213             block.setInstanceName('block');
 214             block.setArraySize(this.m_numInstances);
 215         }
 216     };
 217
 218     /**
 219      * es3fUniformBlockTests.BlockSingleNestedStructArrayCase constructor
 220      * @param {string} name The name of the test
 221      * @param {string} description The description of the test
 222      * @param {number} layoutFlags
 223      * @param {glsUniformBlockCase.BufferMode} bufferMode
 224      * @param {number} numInstances
 225      * @constructor
 226      * @extends {glsUniformBlockCase.UniformBlockCase}
 227      */
 228     es3fUniformBlockTests.BlockSingleNestedStructArrayCase = function(name, description, layoutFlags, bufferMode, numInstances) {
 229         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 230         this.m_layoutFlags = layoutFlags;
 231         this.m_numInstances = numInstances;
 232     };
 233
 234     es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 235     es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype.constructor = es3fUniformBlockTests.BlockSingleNestedStructArrayCase;
 236
 237     es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype.init = function() {
 238         /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S');
 239         typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH));
 240         typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4));
 241         typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
 242
 243         /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T');
 244         typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM));
 245         typeT.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeS), 3));
 246
 247         /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block');
 248         block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0));
 249         block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 250         block.addUniform(new glsUniformBlockCase.Uniform('t', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeT), 2), 0));
 251         block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), 0));
 252         block.setFlags(this.m_layoutFlags);
 253
 254         if (this.m_numInstances > 0) {
 255             block.setInstanceName('block');
 256             block.setArraySize(this.m_numInstances);
 257         }
 258     };
 259
 260     /**
 261      * es3fUniformBlockTests.BlockMultiBasicTypesCase constructor
 262      * @param {string} name The name of the test
 263      * @param {string} description The description of the test
 264      * @param {number} flagsA
 265      * @param {number} flagsB
 266      * @param {glsUniformBlockCase.BufferMode} bufferMode
 267      * @param {number} numInstances
 268      * @constructor
 269      * @extends {glsUniformBlockCase.UniformBlockCase}
 270      */
 271     es3fUniformBlockTests.BlockMultiBasicTypesCase = function(name, description, flagsA, flagsB, bufferMode, numInstances) {
 272         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 273         this.m_flagsA = flagsA;
 274         this.m_flagsB = flagsB;
 275         this.m_numInstances = numInstances;
 276     };
 277
 278     es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 279     es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype.constructor = es3fUniformBlockTests.BlockMultiBasicTypesCase;
 280
 281     es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype.init = function() {
 282         /** @type {glsUniformBlockCase.UniformBlock} */ var blockA = this.m_interface.allocBlock('BlockA');
 283         blockA.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)));
 284         blockA.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 285         blockA.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)));
 286         blockA.setInstanceName('blockA');
 287         blockA.setFlags(this.m_flagsA);
 288
 289         /** @type {glsUniformBlockCase.UniformBlock} */ var blockB = this.m_interface.allocBlock('BlockB');
 290         blockB.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)));
 291         blockB.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW)));
 292         blockB.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 293         blockB.addUniform(new glsUniformBlockCase.Uniform('d', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL, 0)));
 294         blockB.setInstanceName('blockB');
 295         blockB.setFlags(this.m_flagsB);
 296
 297         if (this.m_numInstances > 0) {
 298             blockA.setArraySize(this.m_numInstances);
 299             blockB.setArraySize(this.m_numInstances);
 300         }
 301     };
 302
 303     /**
 304      * es3fUniformBlockTests.BlockMultiNestedStructCase constructor
 305      * @param {string} name The name of the test
 306      * @param {string} description The description of the test
 307      * @param {number} flagsA
 308      * @param {number} flagsB
 309      * @param {glsUniformBlockCase.BufferMode} bufferMode
 310      * @param {number} numInstances
 311      * @constructor
 312      * @extends {glsUniformBlockCase.UniformBlockCase}
 313      */
 314     es3fUniformBlockTests.BlockMultiNestedStructCase = function(name, description, flagsA, flagsB, bufferMode, numInstances) {
 315         glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
 316         this.m_flagsA = flagsA;
 317         this.m_flagsB = flagsB;
 318         this.m_numInstances = numInstances;
 319     };
 320
 321     es3fUniformBlockTests.BlockMultiNestedStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
 322     es3fUniformBlockTests.BlockMultiNestedStructCase.prototype.constructor = es3fUniformBlockTests.BlockMultiNestedStructCase;
 323
 324     es3fUniformBlockTests.BlockMultiNestedStructCase.prototype.init = function() {
 325         /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S');
 326         typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_LOW));
 327         typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4));
 328         typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH));
 329
 330         /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T');
 331         typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
 332         typeT.addMember('b', glsUniformBlockCase.newVarTypeStruct(typeS));
 333         typeT.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL_VEC4, 0));
 334
 335         /** @type {glsUniformBlockCase.UniformBlock} */ var blockA = this.m_interface.allocBlock('BlockA');
 336         blockA.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)));
 337         blockA.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeStruct(typeS)));
 338         blockA.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 339         blockA.setInstanceName('blockA');
 340         blockA.setFlags(this.m_flagsA);
 341
 342         /** @type {glsUniformBlockCase.UniformBlock} */ var blockB = this.m_interface.allocBlock('BlockB');
 343         blockB.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)));
 344         blockB.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeStruct(typeT)));
 345         blockB.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL_VEC4, 0), glsUniformBlockCase.UniformFlags.UNUSED_BOTH));
 346         blockB.addUniform(new glsUniformBlockCase.Uniform('d', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL, 0)));
 347         blockB.setInstanceName('blockB');
 348         blockB.setFlags(this.m_flagsB);
 349
 350         if (this.m_numInstances > 0) {
 351             blockA.setArraySize(this.m_numInstances);
 352             blockB.setArraySize(this.m_numInstances);
 353         }
 354     };
 355
 356     /**
 357      * Creates the test hierarchy to be executed.
 358      **/
 359     es3fUniformBlockTests.init = function() {
 360         /** @const @type {tcuTestCase.DeqpTest} */ var testGroup = tcuTestCase.runner.testCases;
 361
 362         /** @type {Array<gluShaderUtil.DataType>} */
 363         var basicTypes = [
 364             gluShaderUtil.DataType.FLOAT,
 365             gluShaderUtil.DataType.FLOAT_VEC2,
 366             gluShaderUtil.DataType.FLOAT_VEC3,
 367             gluShaderUtil.DataType.FLOAT_VEC4,
 368             gluShaderUtil.DataType.INT,
 369             gluShaderUtil.DataType.INT_VEC2,
 370             gluShaderUtil.DataType.INT_VEC3,
 371             gluShaderUtil.DataType.INT_VEC4,
 372             gluShaderUtil.DataType.UINT,
 373             gluShaderUtil.DataType.UINT_VEC2,
 374             gluShaderUtil.DataType.UINT_VEC3,
 375             gluShaderUtil.DataType.UINT_VEC4,
 376             gluShaderUtil.DataType.BOOL,
 377             gluShaderUtil.DataType.BOOL_VEC2,
 378             gluShaderUtil.DataType.BOOL_VEC3,
 379             gluShaderUtil.DataType.BOOL_VEC4,
 380             gluShaderUtil.DataType.FLOAT_MAT2,
 381             gluShaderUtil.DataType.FLOAT_MAT3,
 382             gluShaderUtil.DataType.FLOAT_MAT4,
 383             gluShaderUtil.DataType.FLOAT_MAT2X3,
 384             gluShaderUtil.DataType.FLOAT_MAT2X4,
 385             gluShaderUtil.DataType.FLOAT_MAT3X2,
 386             gluShaderUtil.DataType.FLOAT_MAT3X4,
 387             gluShaderUtil.DataType.FLOAT_MAT4X2,
 388             gluShaderUtil.DataType.FLOAT_MAT4X3
 389         ];
 390
 391         /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */
 392         var precisionFlags = [{ name: 'lowp', flags: glsUniformBlockCase.UniformFlags.PRECISION_LOW }, { name: 'mediump', flags: glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM }, { name: 'highp', flags: glsUniformBlockCase.UniformFlags.PRECISION_HIGH }
 393         ];
 394
 395         /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */
 396         var layoutFlags = [ /* { name: 'shared', flags: glsUniformBlockCase.UniformFlags.LAYOUT_SHARED }, */
 397             /* { name: 'packed', flags: glsUniformBlockCase.UniformFlags.LAYOUT_PACKED }, */ { name: 'std140', flags: glsUniformBlockCase.UniformFlags.LAYOUT_STD140 }
 398         ];
 399
 400         /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */
 401         var matrixFlags = [{ name: 'row_major', flags: glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR }, { name: 'column_major', flags: glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR }
 402         ];
 403
 404         /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */
 405         var bufferModes = [{ name: 'per_block_buffer', mode: glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK }, { name: 'single_buffer', mode: glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE }
 406         ];
 407
 408         // ubo.single_basic_type
 409         /** @type {tcuTestCase.DeqpTest} */
 410         var singleBasicTypeGroup = tcuTestCase.newTest('single_basic_type', 'Single basic variable in single buffer');
 411
 412         testGroup.addChild(singleBasicTypeGroup);
 413
 414         /** @type {tcuTestCase.DeqpTest} */
 415         var layoutGroup;
 416         /** @type {gluShaderUtil.DataType} */
 417         var type;
 418         /** @type {string} */
 419         var typeName;
 420         /** @type {tcuTestCase.DeqpTest} */
 421         var modeGroup;
 422         /** @type {string} */
 423         var baseName;
 424         /** @type {number} */
 425         var baseFlags;
 426
 427         for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 428
 429             layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, '', null);
 430             singleBasicTypeGroup.addChild(layoutGroup);
 431
 432             for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) {
 433                 type = basicTypes[basicTypeNdx];
 434                 typeName = gluShaderUtil.getDataTypeName(type);
 435
 436                 if (gluShaderUtil.isDataTypeBoolOrBVec(type))
 437                     es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName, glsUniformBlockCase.newVarTypeBasic(type, 0), layoutFlags[layoutFlagNdx].flags);
 438                 else {
 439                     for (var precNdx = 0; precNdx < precisionFlags.length; precNdx++)
 440                         es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, precisionFlags[precNdx].name + '_' + typeName,
 441                         glsUniformBlockCase.newVarTypeBasic(type, precisionFlags[precNdx].flags), layoutFlags[layoutFlagNdx].flags);
 442                 }
 443
 444                 if (gluShaderUtil.isDataTypeMatrix(type)) {
 445                     for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++) {
 446                         for (var precNdx = 0; precNdx < precisionFlags.length; precNdx++)
 447                             es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + precisionFlags[precNdx].name + '_' + typeName,
 448                             glsUniformBlockCase.newVarTypeBasic(type, precisionFlags[precNdx].flags), layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags);
 449                     }
 450                 }
 451             }
 452         }
 453         bufferedLogToConsole('ubo.single_basic_type: Tests created');
 454
 455         // ubo.single_basic_array
 456         /** @type {tcuTestCase.DeqpTest} */
 457         var singleBasicArrayGroup = tcuTestCase.newTest('single_basic_array', 'Single basic array variable in single buffer');
 458         testGroup.addChild(singleBasicArrayGroup);
 459
 460         for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 461             layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, '', null);
 462             singleBasicArrayGroup.addChild(layoutGroup);
 463
 464             for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) {
 465                 type = basicTypes[basicTypeNdx];
 466                 typeName = gluShaderUtil.getDataTypeName(type);
 467                 /** @type {number} */ var arraySize = 3;
 468
 469                 es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName,
 470                     glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(type, gluShaderUtil.isDataTypeBoolOrBVec(type) ? 0 : glsUniformBlockCase.UniformFlags.PRECISION_HIGH), arraySize),
 471                     layoutFlags[layoutFlagNdx].flags);
 472
 473                 if (gluShaderUtil.isDataTypeMatrix(type)) {
 474                     for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++)
 475                         es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + typeName,
 476                         glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(type, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), arraySize),
 477                             layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags);
 478                 }
 479             }
 480         }
 481         bufferedLogToConsole('ubo.single_basic_array: Tests created');
 482
 483         // ubo.single_struct
 484         /** @type {tcuTestCase.DeqpTest} */
 485         var singleStructGroup = tcuTestCase.newTest('single_struct', 'Single struct in uniform block');
 486         testGroup.addChild(singleStructGroup);
 487
 488         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 489             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 490             singleStructGroup.addChild(modeGroup);
 491
 492             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 493                 for (var isArray = 0; isArray < 2; isArray++) {
 494                     baseName = layoutFlags[layoutFlagNdx].name;
 495                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 496
 497                     if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0)
 498                         continue; // Doesn't make sense to add this variant.
 499
 500                     if (isArray)
 501                         baseName += '_instance_array';
 502
 503                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 504                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 505
 506                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 507                         modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 508                 }
 509             }
 510         }
 511         bufferedLogToConsole('ubo.single_struct: Tests created');
 512
 513         // ubo.single_struct_array
 514         /** @type {tcuTestCase.DeqpTest} */
 515         var singleStructArrayGroup = tcuTestCase.newTest('single_struct_array', 'Struct array in one uniform block');
 516         testGroup.addChild(singleStructArrayGroup);
 517
 518         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 519             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 520             singleStructArrayGroup.addChild(modeGroup);
 521
 522             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 523                 for (var isArray = 0; isArray < 2; isArray++) {
 524                     baseName = layoutFlags[layoutFlagNdx].name;
 525                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 526
 527                     if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0)
 528                         continue; // Doesn't make sense to add this variant.
 529
 530                     if (isArray)
 531                         baseName += '_instance_array';
 532
 533                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 534                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 535
 536                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 537                         modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 538                 }
 539             }
 540         }
 541         bufferedLogToConsole('ubo.single_struct_array: Tests created');
 542
 543         // ubo.single_nested_struct
 544         /** @type {tcuTestCase.DeqpTest} */
 545         var singleNestedStructGroup = tcuTestCase.newTest('single_nested_struct', 'Nested struct in one uniform block');
 546         testGroup.addChild(singleNestedStructGroup);
 547
 548         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 549             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 550             singleNestedStructGroup.addChild(modeGroup);
 551
 552             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 553                 for (var isArray = 0; isArray < 2; isArray++) {
 554                     baseName = layoutFlags[layoutFlagNdx].name;
 555                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 556
 557                     if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0)
 558                         continue; // Doesn't make sense to add this variant.
 559
 560                     if (isArray)
 561                         baseName += '_instance_array';
 562
 563                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 564                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 565
 566                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 567                         modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 568                 }
 569             }
 570         }
 571         bufferedLogToConsole('ubo.single_nested_struct: Tests created');
 572
 573         // ubo.single_nested_struct_array
 574         /** @type {tcuTestCase.DeqpTest} */
 575         var singleNestedStructArrayGroup = tcuTestCase.newTest('single_nested_struct_array', 'Nested struct array in one uniform block');
 576         testGroup.addChild(singleNestedStructArrayGroup);
 577
 578         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 579             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 580             singleNestedStructArrayGroup.addChild(modeGroup);
 581
 582             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 583                 for (var isArray = 0; isArray < 2; isArray++) {
 584                     baseName = layoutFlags[layoutFlagNdx].name;
 585                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 586
 587                     if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0)
 588                         continue; // Doesn't make sense to add this variant.
 589
 590                     if (isArray)
 591                         baseName += '_instance_array';
 592
 593                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 594                     modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 595
 596                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 597                         modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 598                 }
 599             }
 600         }
 601         bufferedLogToConsole('ubo.single_nested_struct_array: Tests created');
 602
 603         // ubo.instance_array_basic_type
 604         /** @type {tcuTestCase.DeqpTest} */
 605         var instanceArrayBasicTypeGroup = tcuTestCase.newTest('instance_array_basic_type', 'Single basic variable in instance array');
 606         testGroup.addChild(instanceArrayBasicTypeGroup);
 607
 608         for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 609             layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, '');
 610             instanceArrayBasicTypeGroup.addChild(layoutGroup);
 611
 612             for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) {
 613                 type = basicTypes[basicTypeNdx];
 614                 typeName = gluShaderUtil.getDataTypeName(type);
 615                 /** @type {number} */ var numInstances = 3;
 616
 617                 es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName,
 618                     glsUniformBlockCase.newVarTypeBasic(type, gluShaderUtil.isDataTypeBoolOrBVec(type) ? 0 : glsUniformBlockCase.UniformFlags.PRECISION_HIGH),
 619                     layoutFlags[layoutFlagNdx].flags, numInstances);
 620
 621                 if (gluShaderUtil.isDataTypeMatrix(type)) {
 622                     for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++)
 623                         es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + typeName,
 624                         glsUniformBlockCase.newVarTypeBasic(type, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags,
 625                             numInstances);
 626                 }
 627             }
 628         }
 629         bufferedLogToConsole('ubo.instance_array_basic_type: Tests created');
 630
 631         // ubo.multi_basic_types
 632         /** @type {tcuTestCase.DeqpTest} */
 633         var multiBasicTypesGroup = tcuTestCase.newTest('multi_basic_types', 'Multiple buffers with basic types');
 634         testGroup.addChild(multiBasicTypesGroup);
 635
 636         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 637             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 638             multiBasicTypesGroup.addChild(modeGroup);
 639
 640             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 641                 for (var isArray = 0; isArray < 2; isArray++) {
 642                     baseName = layoutFlags[layoutFlagNdx].name;
 643                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 644
 645                     if (isArray)
 646                         baseName += '_instance_array';
 647
 648                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 649                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 650
 651                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 652                         modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 653
 654                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_mixed', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 655                 }
 656             }
 657         }
 658         bufferedLogToConsole('ubo.multi_basic_types: Tests created');
 659
 660         // ubo.multi_nested_struct
 661         /** @type {tcuTestCase.DeqpTest} */
 662         var multiNestedStructGroup = tcuTestCase.newTest('multi_nested_struct', 'Multiple buffers with basic types');
 663         testGroup.addChild(multiNestedStructGroup);
 664
 665         for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) {
 666             modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, '');
 667             multiNestedStructGroup.addChild(modeGroup);
 668
 669             for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) {
 670                 for (var isArray = 0; isArray < 2; isArray++) {
 671                     baseName = layoutFlags[layoutFlagNdx].name;
 672                     baseFlags = layoutFlags[layoutFlagNdx].flags;
 673
 674                     if (isArray)
 675                         baseName += '_instance_array';
 676
 677                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 678                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 679
 680                     if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED))
 681                         modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 682
 683                     modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_mixed', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0));
 684                 }
 685             }
 686         }
 687         bufferedLogToConsole('ubo.multi_nested_struct: Tests created');
 688
 689         /* ubo.random */
 690          /** @type {number} */ var allShaders = glsRandomUniformBlockCase.FeatureBits.FEATURE_VERTEX_BLOCKS | glsRandomUniformBlockCase.FeatureBits.FEATURE_FRAGMENT_BLOCKS | glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_BLOCKS;
 691          /** @type {number} */ var allLayouts = glsRandomUniformBlockCase.FeatureBits.FEATURE_STD140_LAYOUT;
 692          /** @type {number} */ var allBasicTypes = glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS | glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRICES;
 693          /** @type {number} */ var unused = glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_MEMBERS | glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_UNIFORMS;
 694          /** @type {number} */ var matFlags = glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRIX_LAYOUT;
 695          /** @type {number} */ var allFeatures = (~glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS_OF_ARRAYS & 0xFFFF);
 696
 697          /** @type {tcuTestCase.DeqpTest} */
 698          var randomGroup = tcuTestCase.newTest('random', 'Random Uniform Block cases');
 699          testGroup.addChild(randomGroup);
 700
 701          // Basic types.
 702          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'scalar_types', 'Scalar types only, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused, 25, 0);
 703          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'vector_types', 'Scalar and vector types only, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS, 25, 25);
 704          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_types', 'All basic types, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags, 25, 50);
 705          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_arrays', 'Arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS, 25, 50);
 706
 707          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_instance_arrays', 'Basic instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 75);
 708          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs', 'Nested structs, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS, 25, 100);
 709          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_arrays', 'Nested structs, arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS, 25, 150);
 710          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_instance_arrays', 'Nested structs, instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 125);
 711          es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_arrays_instance_arrays', 'Nested structs, instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 175);
 712
 713          // Disabled: WebGL does not support shared or packed uniform buffers.
 714          //es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'all_per_block_buffers', 'All random features, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allFeatures, 50, 200);
 715          //es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'all_shared_buffer', 'All random features, shared buffer', glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE, allFeatures, 50, 250);
 716          bufferedLogToConsole('ubo.random: Tests created');
 717     };
 718
 719     /**
 720      * Create and execute the test cases
 721      */
 722     es3fUniformBlockTests.run = function(range) {
 723         //Set up Test Root parameters
 724         var testName = 'ubo';
 725         var testDescription = 'Uniform Block Tests';
 726         var state = tcuTestCase.runner;
 727
 728         state.setRoot(tcuTestCase.newTest(testName, testDescription, null));
 729
 730         //Set up name and description of this test series.
 731         setCurrentTestName(testName);
 732         description(testDescription);
 733
 734         try {
 735             //Create test cases
 736             es3fUniformBlockTests.init();
 737             if (range)
 738                 state.setRange(range);
 739             //Run test cases
 740             tcuTestCase.runTestCases();
 741         }
 742         catch (err) {
 743             testFailedOptions('Failed to es3fUniformBlockTests.run tests', false);
 744             tcuTestCase.runner.terminate();
 745         }
 746     };
 747
 748 });