modules/gles31/functional/es31fUniformLocationTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   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  * \file
  21  * \brief Explicit uniform location tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fUniformLocationTests.hpp"
  25
  26 #include "tcuTestLog.hpp"
  27 #include "tcuTextureUtil.hpp"
  28 #include "tcuVectorUtil.hpp"
  29 #include "tcuCommandLine.hpp"
  30
  31 #include "glsShaderLibrary.hpp"
  32 #include "glsTextureTestUtil.hpp"
  33
  34 #include "gluShaderProgram.hpp"
  35 #include "gluTexture.hpp"
  36 #include "gluPixelTransfer.hpp"
  37 #include "gluVarType.hpp"
  38 #include "gluVarTypeUtil.hpp"
  39
  40 #include "glwFunctions.hpp"
  41 #include "glwEnums.hpp"
  42 #include "sglrContextUtil.hpp"
  43
  44 #include "deStringUtil.hpp"
  45 #include "deUniquePtr.hpp"
  46 #include "deString.h"
  47 #include "deRandom.hpp"
  48 #include "deInt32.h"
  49
  50 #include <set>
  51 #include <map>
  52
  53 namespace deqp
  54 {
  55 namespace gles31
  56 {
  57 namespace Functional
  58 {
  59 namespace
  60 {
  61
  62 using std::string;
  63 using std::vector;
  64 using std::map;
  65 using de::UniquePtr;
  66 using glu::VarType;
  67
  68 struct UniformInfo
  69 {
  70         enum ShaderStage
  71         {
  72                 SHADERSTAGE_NONE        = 0,
  73                 SHADERSTAGE_VERTEX      = (1<<0),
  74                 SHADERSTAGE_FRAGMENT= (1<<1),
  75                 SHADERSTAGE_BOTH        = (SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT),
  76         };
  77
  78         VarType                 type;
  79         ShaderStage             declareLocation; // support declarations with/without layout qualifiers, needed for linkage testing
  80         ShaderStage             layoutLocation;
  81         ShaderStage             checkLocation;
  82         int                             location; // -1 for unset
  83
  84         UniformInfo (VarType type_, ShaderStage declareLocation_, ShaderStage layoutLocation_, ShaderStage checkLocation_, int location_ = -1)
  85                 : type                          (type_)
  86                 , declareLocation       (declareLocation_)
  87                 , layoutLocation        (layoutLocation_)
  88                 , checkLocation         (checkLocation_)
  89                 , location                      (location_)
  90         {
  91         }
  92 };
  93
  94 class UniformLocationCase : public tcu::TestCase
  95 {
  96 public:
  97                                                                 UniformLocationCase             (tcu::TestContext&                      context,
  98                                                                                                                  glu::RenderContext&            renderContext,
  99                                                                                                                  const char*                            name,
 100                                                                                                                  const char*                            desc,
 101                                                                                                                  const vector<UniformInfo>&     uniformInfo);
 102         virtual                                         ~UniformLocationCase    (void) {}
 103
 104         virtual IterateResult           iterate                                 (void);
 105
 106 protected:
 107         IterateResult                           run                                             (const vector<UniformInfo>& uniformList);
 108         static glu::ProgramSources      genShaderSources                (const vector<UniformInfo>& uniformList);
 109         bool                                            verifyLocations                 (const glu::ShaderProgram& program, const vector<UniformInfo>& uniformList);
 110         void                                            render                                  (const glu::ShaderProgram& program, const vector<UniformInfo>& uniformList);
 111         static bool                                     verifyResult                    (const tcu::ConstPixelBufferAccess& access);
 112
 113         static float                            getExpectedValue                (glu::DataType type, int id, const char* name);
 114
 115         de::MovePtr<glu::Texture2D>     createTexture                   (glu::DataType samplerType, float redChannelValue, int binding);
 116
 117         glu::RenderContext&                     m_renderCtx;
 118
 119         const vector<UniformInfo>       m_uniformInfo;
 120
 121         enum
 122         {
 123                 RENDER_SIZE = 16
 124         };
 125 };
 126
 127 string getUniformName (int ndx, const glu::VarType& type, const glu::TypeComponentVector& path)
 128 {
 129         std::ostringstream buff;
 130         buff << "uni" << ndx << glu::TypeAccessFormat(type, path);
 131
 132         return buff.str();
 133 }
 134
 135 string getFirstComponentName (const glu::VarType& type)
 136 {
 137         std::ostringstream buff;
 138         if (glu::isDataTypeVector(type.getBasicType()))
 139                 buff << glu::TypeAccessFormat(type, glu::SubTypeAccess(type).component(0).getPath());
 140         else if (glu::isDataTypeMatrix(type.getBasicType()))
 141                 buff << glu::TypeAccessFormat(type, glu::SubTypeAccess(type).column(0).component(0).getPath());
 142
 143         return buff.str();
 144 }
 145
 146 UniformLocationCase::UniformLocationCase (tcu::TestContext&                             context,
 147                                                                                   glu::RenderContext&                   renderContext,
 148                                                                                   const char*                                   name,
 149                                                                                   const char*                                   desc,
 150                                                                                   const vector<UniformInfo>&    uniformInfo)
 151         : TestCase                      (context, name, desc)
 152         , m_renderCtx           (renderContext)
 153         , m_uniformInfo         (uniformInfo)
 154 {
 155 }
 156
 157 // [from, to]
 158 std::vector<int> shuffledRange (int from, int to, int seed)
 159 {
 160         const int       count   = to - from;
 161
 162         vector<int> retval      (count);
 163         de::Random      rng             (seed);
 164
 165         DE_ASSERT(count > 0);
 166
 167         for (int ndx = 0; ndx < count; ndx++)
 168                 retval[ndx] = ndx + from;
 169
 170         rng.shuffle(retval.begin(), retval.end());
 171         return retval;
 172 }
 173
 174 glu::DataType getDataTypeSamplerSampleType (glu::DataType type)
 175 {
 176         using namespace glu;
 177
 178         if (type >= TYPE_SAMPLER_1D && type <= TYPE_SAMPLER_3D)
 179                 return TYPE_FLOAT_VEC4;
 180         else if (type >= TYPE_INT_SAMPLER_1D && type <= TYPE_INT_SAMPLER_3D)
 181                 return TYPE_INT_VEC4;
 182         else if (type >= TYPE_UINT_SAMPLER_1D && type <= TYPE_UINT_SAMPLER_3D)
 183                 return TYPE_UINT_VEC4;
 184         else if (type >= TYPE_SAMPLER_1D_SHADOW && type <=      TYPE_SAMPLER_2D_ARRAY_SHADOW)
 185                 return TYPE_FLOAT;
 186         else
 187                 DE_FATAL("Unknown sampler type");
 188
 189         return TYPE_INVALID;
 190 }
 191
 192 // A (hopefully) unique value for a uniform. For multi-component types creates only one value. Values are in the range [0,1] for floats, [-128, 127] for ints, [0,255] for uints and 0/1 for booleans. Samplers are treated according to the types they return.
 193 float UniformLocationCase::getExpectedValue (glu::DataType type, int id, const char* name)
 194 {
 195         const deUint32  hash                    = deStringHash(name) + deInt32Hash(id);
 196
 197         glu::DataType   adjustedType    = type;
 198
 199         if (glu::isDataTypeSampler(type))
 200                 adjustedType = getDataTypeSamplerSampleType(type);
 201
 202         if (glu::isDataTypeIntOrIVec(adjustedType))
 203                 return float(hash%128);
 204         else if (glu::isDataTypeUintOrUVec(adjustedType))
 205                 return float(hash%255);
 206         else if (glu::isDataTypeFloatOrVec(adjustedType))
 207                 return float(hash%255)/255.0f;
 208         else if (glu::isDataTypeBoolOrBVec(adjustedType))
 209                 return float(hash%2);
 210         else
 211                 DE_FATAL("Unkown primitive type");
 212
 213         return glu::TYPE_INVALID;
 214 }
 215
 216 UniformLocationCase::IterateResult UniformLocationCase::iterate (void)
 217 {
 218         return run(m_uniformInfo);
 219 }
 220
 221 UniformLocationCase::IterateResult UniformLocationCase::run (const vector<UniformInfo>& uniformList)
 222 {
 223         using gls::TextureTestUtil::RandomViewport;
 224
 225         const glu::ProgramSources       sources         = genShaderSources(uniformList);
 226         const glu::ShaderProgram        program         (m_renderCtx, sources);
 227         const int                                       baseSeed        = m_testCtx.getCommandLine().getBaseSeed();
 228         const glw::Functions&           gl                      = m_renderCtx.getFunctions();
 229         const RandomViewport            viewport        (m_renderCtx.getRenderTarget(), RENDER_SIZE, RENDER_SIZE, deStringHash(getName()) + baseSeed);
 230
 231         tcu::Surface                            rendered        (RENDER_SIZE, RENDER_SIZE);
 232
 233         if (!verifyLocations(program, uniformList))
 234                 return STOP;
 235
 236         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 237         gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 238         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 239
 240         render(program, uniformList);
 241
 242         glu::readPixels(m_renderCtx, viewport.x, viewport.y, rendered.getAccess());
 243
 244         if (!verifyResult(rendered.getAccess()))
 245         {
 246                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader produced incorrect result");
 247                 return STOP;
 248         }
 249
 250         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 251         return STOP;
 252 }
 253
 254 glu::ProgramSources UniformLocationCase::genShaderSources (const vector<UniformInfo>& uniformList)
 255 {
 256         std::ostringstream      vertDecl, vertMain, fragDecl, fragMain;
 257
 258         vertDecl << "#version 310 es\n"
 259                          << "precision highp float;\n"
 260                          << "precision highp int;\n"
 261                          << "float verify(float val, float ref) { return float(abs(val-ref) < 0.05); }\n\n"
 262                          << "in highp vec4 a_position;\n"
 263                          << "out highp vec4 v_color;\n";
 264         fragDecl << "#version 310 es\n\n"
 265                          << "precision highp float;\n"
 266                          << "precision highp int;\n"
 267                          << "float verify(float val, float ref) { return float(abs(val-ref) < 0.05); }\n\n"
 268                          << "in highp vec4 v_color;\n"
 269                          << "layout(location = 0) out mediump vec4 o_color;\n\n";
 270
 271         vertMain << "void main()\n{\n"
 272                          << "   gl_Position = a_position;\n"
 273                          << "   v_color = vec4(1.0);\n";
 274
 275         fragMain << "void main()\n{\n"
 276                          << "   o_color = v_color;\n";
 277
 278         std::set<const glu::StructType*> declaredStructs;
 279
 280         // Declare uniforms
 281         for (int uniformNdx = 0; uniformNdx < int(uniformList.size()); uniformNdx++)
 282         {
 283                 const UniformInfo&      uniformInfo = uniformList[uniformNdx];
 284
 285                 const bool                      declareInVert   = (uniformInfo.declareLocation & UniformInfo::SHADERSTAGE_VERTEX)   != 0;
 286                 const bool                      declareInFrag   = (uniformInfo.declareLocation & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;
 287                 const bool                      layoutInVert    = (uniformInfo.layoutLocation  & UniformInfo::SHADERSTAGE_VERTEX)   != 0;
 288                 const bool                      layoutInFrag    = (uniformInfo.layoutLocation  & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;
 289                 const bool                      checkInVert             = (uniformInfo.checkLocation   & UniformInfo::SHADERSTAGE_VERTEX)   != 0;
 290                 const bool                      checkInFrag             = (uniformInfo.checkLocation   & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;
 291
 292                 const string            layout                  = uniformInfo.location >= 0 ? "layout(location = " + de::toString(uniformInfo.location) + ") " : "";
 293                 const string            uniName                 = "uni" + de::toString(uniformNdx);
 294
 295                 int                                     location                = uniformInfo.location;
 296                 int                                     subTypeIndex    = 0;
 297
 298                 DE_ASSERT((declareInVert && layoutInVert) || !layoutInVert); // Cannot have layout without declaration
 299                 DE_ASSERT((declareInFrag && layoutInFrag) || !layoutInFrag);
 300                 DE_ASSERT(location<0 || (layoutInVert || layoutInFrag)); // Cannot have location without layout
 301
 302                 // struct definitions
 303                 if (uniformInfo.type.isStructType())
 304                 {
 305                         const glu::StructType* const structType = uniformInfo.type.getStructPtr();
 306                         if (!declaredStructs.count(structType))
 307                         {
 308                                 if (declareInVert)
 309                                         vertDecl << glu::declare(structType, 0) << ";\n";
 310
 311                                 if (declareInFrag)
 312                                         fragDecl << glu::declare(structType, 0) << ";\n";
 313
 314                                 declaredStructs.insert(structType);
 315                         }
 316                 }
 317
 318                 if (declareInVert)
 319                         vertDecl << "uniform " << (layoutInVert ? layout : "") << glu::declare(uniformInfo.type, uniName) << ";\n";
 320
 321                 if (declareInFrag)
 322                         fragDecl << "uniform " << (layoutInFrag ? layout : "") << glu::declare(uniformInfo.type, uniName) << ";\n";
 323
 324                 // Anything that needs to be done for each enclosed primitive type
 325                 for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type); subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++, subTypeIndex++)
 326                 {
 327                         const glu::VarType      subType         = glu::getVarType(uniformInfo.type, subTypeIter.getPath());
 328                         const glu::DataType     scalarType      = glu::getDataTypeScalarType(subType.getBasicType());
 329                         const char* const       typeName        = glu::getDataTypeName(scalarType);
 330                         const string            expectValue     = de::floatToString(getExpectedValue(scalarType, location >= 0 ? location+subTypeIndex : -1, typeName), 3);
 331
 332                         if (glu::isDataTypeSampler(scalarType))
 333                         {
 334                                 if (checkInVert)
 335                                         vertMain << "   v_color.rgb *= verify(float( texture(" << uniName
 336                                                          << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
 337                                                          << ", vec2(0.5)).r), " << expectValue << ");\n";
 338                                 if (checkInFrag)
 339                                         fragMain << "   o_color.rgb *= verify(float( texture(" << uniName
 340                                                          << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
 341                                                          << ", vec2(0.5)).r), " << expectValue << ");\n";
 342                         }
 343                         else
 344                         {
 345                                 if (checkInVert)
 346                                         vertMain << "   v_color.rgb *= verify(float(" << uniName
 347                                                          << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
 348                                                          << getFirstComponentName(subType) << "), " << expectValue << ");\n";
 349                                 if (checkInFrag)
 350                                         fragMain << "   o_color.rgb *= verify(float(" << uniName
 351                                                          << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
 352                                                          << getFirstComponentName(subType) << "), " << expectValue << ");\n";
 353                         }
 354                 }
 355         }
 356
 357         vertMain << "}\n";
 358         fragMain << "}\n";
 359
 360         return glu::makeVtxFragSources(vertDecl.str() + vertMain.str(), fragDecl.str() + fragMain.str());
 361 }
 362
 363 bool UniformLocationCase::verifyLocations (const glu::ShaderProgram& program, const vector<UniformInfo>& uniformList)
 364 {
 365         using tcu::TestLog;
 366
 367         const glw::Functions&   gl                      = m_renderCtx.getFunctions();
 368         const bool                              vertexOk        = program.getShaderInfo(glu::SHADERTYPE_VERTEX).compileOk;
 369         const bool                              fragmentOk      = program.getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk;
 370         const bool                              linkOk          = program.getProgramInfo().linkOk;
 371         const deUint32                  programID       = program.getProgram();
 372
 373         TestLog&                                log                     = m_testCtx.getLog();
 374         std::set<int>                   usedLocations;
 375
 376         log << program;
 377
 378         if (!vertexOk || !fragmentOk || !linkOk)
 379         {
 380                 log << TestLog::Message << "ERROR: shader failed to compile/link" << TestLog::EndMessage;
 381                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader failed to compile/link");
 382                 return false;
 383         }
 384
 385         for (int uniformNdx = 0; uniformNdx < int(uniformList.size()); uniformNdx++)
 386         {
 387                 const UniformInfo&      uniformInfo             = uniformList[uniformNdx];
 388                 int                                     subTypeIndex    = 0;
 389
 390                 for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type); subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++, subTypeIndex++)
 391                 {
 392                         const string            name            = getUniformName(uniformNdx, uniformInfo.type, subTypeIter.getPath());
 393                         const int                       gotLoc          = gl.getUniformLocation(programID, name.c_str());
 394                         const int                       expectLoc       = uniformInfo.location >= 0 ? uniformInfo.location+subTypeIndex : -1;
 395
 396                         if (expectLoc >= 0)
 397                         {
 398                                 if (uniformInfo.checkLocation == 0 && gotLoc == -1)
 399                                         continue;
 400
 401                                 if (gotLoc != expectLoc)
 402                                 {
 403                                         log << TestLog::Message << "ERROR: found uniform " << name << " in location " << gotLoc << " when it should have been in " << expectLoc << TestLog::EndMessage;
 404                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Incorrect uniform location");
 405                                         return false;
 406                                 }
 407
 408                                 if (usedLocations.find(expectLoc) != usedLocations.end())
 409                                 {
 410                                         log << TestLog::Message << "ERROR: expected uniform " << name << " in location " << gotLoc << " but it has already been used" << TestLog::EndMessage;
 411                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Overlapping uniform location");
 412                                         return false;
 413                                 }
 414
 415                                 usedLocations.insert(expectLoc);
 416                         }
 417                         else if (gotLoc >= 0)
 418                         {
 419                                 if (usedLocations.count(gotLoc))
 420                                 {
 421                                         log << TestLog::Message << "ERROR: found uniform " << name << " in location " << gotLoc << " which has already been used" << TestLog::EndMessage;
 422                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Overlapping uniform location");
 423                                         return false;
 424                                 }
 425
 426                                 usedLocations.insert(gotLoc);
 427                         }
 428                 }
 429         }
 430
 431         return true;
 432 }
 433
 434 // Check that shader output is white (or very close to it)
 435 bool UniformLocationCase::verifyResult (const tcu::ConstPixelBufferAccess& access)
 436 {
 437         using tcu::Vec4;
 438
 439         const Vec4 threshold (0.1f, 0.1f, 0.1f, 0.1f);
 440         const Vec4 reference (1.0f, 1.0f, 1.0f, 1.0f);
 441
 442         for (int y = 0; y < access.getHeight(); y++)
 443         {
 444                 for (int x = 0; x < access.getWidth(); x++)
 445                 {
 446                         const Vec4 diff = abs(access.getPixel(x, y) - reference);
 447
 448                         if (!boolAll(lessThanEqual(diff, threshold)))
 449                                 return false;
 450                 }
 451         }
 452
 453         return true;
 454 }
 455
 456 // get a 4 channel 8 bits each texture format that is usable by the given sampler type
 457 deUint32 getTextureFormat (glu::DataType samplerType)
 458 {
 459         using namespace glu;
 460
 461         switch (samplerType)
 462         {
 463                 case TYPE_SAMPLER_1D:
 464                 case TYPE_SAMPLER_2D:
 465                 case TYPE_SAMPLER_CUBE:
 466                 case TYPE_SAMPLER_2D_ARRAY:
 467                 case TYPE_SAMPLER_3D:
 468                         return GL_RGBA8;
 469
 470                 case TYPE_INT_SAMPLER_1D:
 471                 case TYPE_INT_SAMPLER_2D:
 472                 case TYPE_INT_SAMPLER_CUBE:
 473                 case TYPE_INT_SAMPLER_2D_ARRAY:
 474                 case TYPE_INT_SAMPLER_3D:
 475                         return GL_RGBA8I;
 476
 477                 case TYPE_UINT_SAMPLER_1D:
 478                 case TYPE_UINT_SAMPLER_2D:
 479                 case TYPE_UINT_SAMPLER_CUBE:
 480                 case TYPE_UINT_SAMPLER_2D_ARRAY:
 481                 case TYPE_UINT_SAMPLER_3D:
 482                         return GL_RGBA8UI;
 483
 484                 default:
 485                         DE_FATAL("Unsupported (sampler) type");
 486                         return 0;
 487         }
 488 }
 489
 490 // create a texture suitable for sampling by the given sampler type and bind it
 491 de::MovePtr<glu::Texture2D> UniformLocationCase::createTexture (glu::DataType samplerType, float redChannelValue, int binding)
 492 {
 493         using namespace glu;
 494
 495         const glw::Functions&   gl               = m_renderCtx.getFunctions();
 496
 497         const deUint32                  format   = getTextureFormat(samplerType);
 498         de::MovePtr<Texture2D>  tex;
 499
 500         tex = de::MovePtr<Texture2D>(new Texture2D(m_renderCtx, format, 16, 16));
 501
 502         tex->getRefTexture().allocLevel(0);
 503
 504         if (format == GL_RGBA8I || format == GL_RGBA8UI)
 505                 tcu::clear(tex->getRefTexture().getLevel(0), tcu::IVec4(int(redChannelValue), 0, 0, 0));
 506         else
 507                 tcu::clear(tex->getRefTexture().getLevel(0), tcu::Vec4(redChannelValue, 0.0f, 0.0f, 1.0f));
 508
 509         gl.activeTexture(GL_TEXTURE0 + binding);
 510         tex->upload();
 511
 512         gl.bindTexture(GL_TEXTURE_2D, tex->getGLTexture());
 513         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 514         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 515
 516         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformLocationCase: texture upload");
 517
 518         return tex;
 519 }
 520
 521 void UniformLocationCase::render (const glu::ShaderProgram& program, const vector<UniformInfo>& uniformList)
 522 {
 523         using glu::Texture2D;
 524         using de::MovePtr;
 525         typedef vector<Texture2D*> TextureList;
 526
 527         const glw::Functions&   gl                              = m_renderCtx.getFunctions();
 528         const deUint32                  programID               = program.getProgram();
 529         const deInt32                   posLoc                  = gl.getAttribLocation(programID, "a_position");
 530
 531         // Vertex data.
 532         const float position[] =
 533         {
 534                 -1.0f, -1.0f, 0.1f,     1.0f,
 535                 -1.0f,  1.0f, 0.1f,     1.0f,
 536                  1.0f, -1.0f, 0.1f,     1.0f,
 537                  1.0f,  1.0f, 0.1f,     1.0f
 538         };
 539         const deUint16                  indices[]               = { 0, 1, 2, 2, 1, 3 };
 540
 541         // some buffers to feed to the GPU, only the first element is relevant since the others are never verified
 542         float                                   floatBuf[16]    = {0.0f};
 543         deInt32                                 intBuf[4]               = {0};
 544         deUint32                                uintBuf[4]              = {0};
 545
 546         TextureList                             texList;
 547
 548         TCU_CHECK(posLoc >= 0);
 549         gl.useProgram(programID);
 550
 551         try
 552         {
 553
 554                 // Set uniforms
 555                 for (unsigned int uniformNdx = 0; uniformNdx < uniformList.size(); uniformNdx++)
 556                 {
 557                         const UniformInfo&      uniformInfo                     = uniformList[uniformNdx];
 558                         int                                     expectedLocation        = uniformInfo.location;
 559
 560                         for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type); subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++)
 561                         {
 562                                 const glu::VarType      type                    = glu::getVarType(uniformInfo.type, subTypeIter.getPath());
 563                                 const string            name                    = getUniformName(uniformNdx, uniformInfo.type, subTypeIter.getPath());
 564                                 const int                       gotLoc                  = gl.getUniformLocation(programID, name.c_str());
 565                                 const glu::DataType     scalarType              = glu::getDataTypeScalarType(type.getBasicType());
 566                                 const char*     const   typeName                = glu::getDataTypeName(scalarType);
 567                                 const float                     expectedValue   = getExpectedValue(scalarType, expectedLocation, typeName);
 568
 569                                 if (glu::isDataTypeSampler(scalarType))
 570                                 {
 571                                         const int binding = (int)texList.size();
 572
 573                                         texList.push_back(createTexture(scalarType, expectedValue, binding).release());
 574                                         gl.uniform1i(gotLoc, binding);
 575                                 }
 576                                 else if(gotLoc >= 0)
 577                                 {
 578                                         floatBuf[0] = expectedValue;
 579                                         intBuf[0]   = int(expectedValue);
 580                                         uintBuf[0]  = deUint32(expectedValue);
 581
 582                                         m_testCtx.getLog() << tcu::TestLog::Message << "Set uniform " << name << " in location " << gotLoc << " to " << expectedValue << tcu::TestLog::EndMessage;
 583
 584                                         switch (type.getBasicType())
 585                                         {
 586                                                 case glu::TYPE_FLOAT:                   gl.uniform1fv(gotLoc, 1, floatBuf);                                     break;
 587                                                 case glu::TYPE_FLOAT_VEC2:              gl.uniform2fv(gotLoc, 1, floatBuf);                                     break;
 588                                                 case glu::TYPE_FLOAT_VEC3:              gl.uniform3fv(gotLoc, 1, floatBuf);                                     break;
 589                                                 case glu::TYPE_FLOAT_VEC4:              gl.uniform4fv(gotLoc, 1, floatBuf);                                     break;
 590
 591                                                 case glu::TYPE_INT:                             gl.uniform1iv(gotLoc, 1, intBuf);                                       break;
 592                                                 case glu::TYPE_INT_VEC2:                gl.uniform2iv(gotLoc, 1, intBuf);                                       break;
 593                                                 case glu::TYPE_INT_VEC3:                gl.uniform3iv(gotLoc, 1, intBuf);                                       break;
 594                                                 case glu::TYPE_INT_VEC4:                gl.uniform4iv(gotLoc, 1, intBuf);                                       break;
 595
 596                                                 case glu::TYPE_UINT:                    gl.uniform1uiv(gotLoc, 1, uintBuf);                                     break;
 597                                                 case glu::TYPE_UINT_VEC2:               gl.uniform2uiv(gotLoc, 1, uintBuf);                                     break;
 598                                                 case glu::TYPE_UINT_VEC3:               gl.uniform3uiv(gotLoc, 1, uintBuf);                                     break;
 599                                                 case glu::TYPE_UINT_VEC4:               gl.uniform4uiv(gotLoc, 1, uintBuf);                                     break;
 600
 601                                                 case glu::TYPE_BOOL:                    gl.uniform1iv(gotLoc, 1, intBuf);                                       break;
 602                                                 case glu::TYPE_BOOL_VEC2:               gl.uniform2iv(gotLoc, 1, intBuf);                                       break;
 603                                                 case glu::TYPE_BOOL_VEC3:               gl.uniform3iv(gotLoc, 1, intBuf);                                       break;
 604                                                 case glu::TYPE_BOOL_VEC4:               gl.uniform4iv(gotLoc, 1, intBuf);                                       break;
 605
 606                                                 case glu::TYPE_FLOAT_MAT2:              gl.uniformMatrix2fv(gotLoc, 1, false, floatBuf);        break;
 607                                                 case glu::TYPE_FLOAT_MAT2X3:    gl.uniformMatrix2x3fv(gotLoc, 1, false, floatBuf);      break;
 608                                                 case glu::TYPE_FLOAT_MAT2X4:    gl.uniformMatrix2x4fv(gotLoc, 1, false, floatBuf);      break;
 609
 610                                                 case glu::TYPE_FLOAT_MAT3X2:    gl.uniformMatrix3x2fv(gotLoc, 1, false, floatBuf);      break;
 611                                                 case glu::TYPE_FLOAT_MAT3:              gl.uniformMatrix3fv(gotLoc, 1, false, floatBuf);        break;
 612                                                 case glu::TYPE_FLOAT_MAT3X4:    gl.uniformMatrix3x4fv(gotLoc, 1, false, floatBuf);      break;
 613
 614                                                 case glu::TYPE_FLOAT_MAT4X2:    gl.uniformMatrix4x2fv(gotLoc, 1, false, floatBuf);      break;
 615                                                 case glu::TYPE_FLOAT_MAT4X3:    gl.uniformMatrix4x3fv(gotLoc, 1, false, floatBuf);      break;
 616                                                 case glu::TYPE_FLOAT_MAT4:              gl.uniformMatrix4fv(gotLoc, 1, false, floatBuf);        break;
 617                                                 default:
 618                                                         DE_ASSERT(false);
 619                                         }
 620                                 }
 621
 622                                 expectedLocation += expectedLocation>=0;
 623                         }
 624                 }
 625
 626                 gl.enableVertexAttribArray(posLoc);
 627                 gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &position[0]);
 628
 629                 gl.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0]);
 630
 631                 gl.disableVertexAttribArray(posLoc);
 632         }
 633         catch(...)
 634         {
 635                 for (int i = 0; i < int(texList.size()); i++)
 636                         delete texList[i];
 637
 638                 throw;
 639         }
 640
 641         for (int i = 0; i < int(texList.size()); i++)
 642                 delete texList[i];
 643 }
 644
 645 class MaxUniformLocationCase : public UniformLocationCase
 646 {
 647 public:
 648                                                                 MaxUniformLocationCase          (tcu::TestContext&                      context,
 649                                                                                                                          glu::RenderContext&            renderContext,
 650                                                                                                                          const char*                            name,
 651                                                                                                                          const char*                            desc,
 652                                                                                                                          const vector<UniformInfo>&     uniformInfo);
 653         virtual                                         ~MaxUniformLocationCase         (void) {}
 654         virtual IterateResult           iterate                                         (void);
 655 };
 656
 657 MaxUniformLocationCase::MaxUniformLocationCase (tcu::TestContext&                       context,
 658                                                                                                 glu::RenderContext&                     renderContext,
 659                                                                                                 const char*                                     name,
 660                                                                                                 const char*                                     desc,
 661                                                                                                 const vector<UniformInfo>&      uniformInfo)
 662         : UniformLocationCase(context, renderContext, name, desc, uniformInfo)
 663 {
 664         DE_ASSERT(!uniformInfo.empty());
 665 }
 666
 667 UniformLocationCase::IterateResult MaxUniformLocationCase::iterate (void)
 668 {
 669         int                                     maxLocation = 1024;
 670         vector<UniformInfo>     uniformInfo = m_uniformInfo;
 671
 672         m_renderCtx.getFunctions().getIntegerv(GL_MAX_UNIFORM_LOCATIONS, &maxLocation);
 673
 674         uniformInfo[0].location = maxLocation-1;
 675
 676         return UniformLocationCase::run(uniformInfo);
 677 }
 678
 679 } // Anonymous
 680
 681 UniformLocationTests::UniformLocationTests (Context& context)
 682         : TestCaseGroup(context, "uniform_location", "Explicit uniform locations")
 683 {
 684 }
 685
 686 UniformLocationTests::~UniformLocationTests (void)
 687 {
 688         for (int i = 0; i < int(structTypes.size()); i++)
 689                 delete structTypes[i];
 690 }
 691
 692 glu::VarType createVarType (glu::DataType type)
 693 {
 694         return glu::VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP);
 695 }
 696
 697 void UniformLocationTests::init (void)
 698 {
 699         using namespace glu;
 700
 701         const UniformInfo::ShaderStage checkStages[]    = { UniformInfo::SHADERSTAGE_VERTEX, UniformInfo::SHADERSTAGE_FRAGMENT };
 702         const char*                                             stageNames[]    = {"vertex", "fragment"};
 703         const int                                               maxLocations    = 1024;
 704         const int                                               baseSeed                = m_context.getTestContext().getCommandLine().getBaseSeed();
 705
 706         const DataType                                  primitiveTypes[] =
 707         {
 708                 TYPE_FLOAT,
 709                 TYPE_FLOAT_VEC2,
 710                 TYPE_FLOAT_VEC3,
 711                 TYPE_FLOAT_VEC4,
 712
 713                 TYPE_INT,
 714                 TYPE_INT_VEC2,
 715                 TYPE_INT_VEC3,
 716                 TYPE_INT_VEC4,
 717
 718                 TYPE_UINT,
 719                 TYPE_UINT_VEC2,
 720                 TYPE_UINT_VEC3,
 721                 TYPE_UINT_VEC4,
 722
 723                 TYPE_BOOL,
 724                 TYPE_BOOL_VEC2,
 725                 TYPE_BOOL_VEC3,
 726                 TYPE_BOOL_VEC4,
 727
 728                 TYPE_FLOAT_MAT2,
 729                 TYPE_FLOAT_MAT2X3,
 730                 TYPE_FLOAT_MAT2X4,
 731                 TYPE_FLOAT_MAT3X2,
 732                 TYPE_FLOAT_MAT3,
 733                 TYPE_FLOAT_MAT3X4,
 734                 TYPE_FLOAT_MAT4X2,
 735                 TYPE_FLOAT_MAT4X3,
 736                 TYPE_FLOAT_MAT4,
 737
 738                 TYPE_SAMPLER_2D,
 739                 TYPE_INT_SAMPLER_2D,
 740                 TYPE_UINT_SAMPLER_2D,
 741         };
 742
 743         const int maxPrimitiveTypeNdx = DE_LENGTH_OF_ARRAY(primitiveTypes) - 4;
 744         DE_ASSERT(primitiveTypes[maxPrimitiveTypeNdx] == TYPE_FLOAT_MAT4);
 745
 746         // Primitive type cases with trivial linkage
 747         {
 748                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "basic", "Location specified with use, single shader stage");
 749                 de::Random                                      rng             (baseSeed + 0x1001);
 750                 addChild(group);
 751
 752                 for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
 753                 {
 754                         const DataType          type    = primitiveTypes[primitiveNdx];
 755
 756                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
 757                         {
 758                                 const string            name            = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
 759
 760                                 vector<UniformInfo> config;
 761
 762                                 UniformInfo                     uniform (createVarType(type),
 763                                                                                          checkStages[stageNdx],
 764                                                                                          checkStages[stageNdx],
 765                                                                                          checkStages[stageNdx],
 766                                                                                          rng.getInt(0, maxLocations-1));
 767
 768                                 config.push_back(uniform);
 769                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
 770                         }
 771                 }
 772         }
 773
 774         // Arrays
 775         {
 776                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "array", "Array location specified with use, single shader stage");
 777                 de::Random                                      rng             (baseSeed + 0x2001);
 778                 addChild(group);
 779
 780                 for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
 781                 {
 782                         const DataType          type    = primitiveTypes[primitiveNdx];
 783
 784                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
 785                         {
 786
 787                                 const string            name    = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
 788
 789                                 vector<UniformInfo> config;
 790
 791                                 UniformInfo                     uniform (VarType(createVarType(type), 8),
 792                                                                                                 checkStages[stageNdx],
 793                                                                                                 checkStages[stageNdx],
 794                                                                                                 checkStages[stageNdx],
 795                                                                                                 rng.getInt(0, maxLocations-1-8));
 796
 797                                 config.push_back(uniform);
 798                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
 799                         }
 800                 }
 801         }
 802
 803         // Nested Arrays
 804         {
 805                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "nested_array", "Array location specified with use, single shader stage");
 806                 de::Random                                      rng             (baseSeed + 0x3001);
 807                 addChild(group);
 808
 809                 for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
 810                 {
 811                         const DataType          type    = primitiveTypes[primitiveNdx];
 812
 813                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
 814                         {
 815                                 const string            name            = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
 816                                 // stay comfortably within minimum max uniform component count (896 in fragment) and sampler count with all types
 817                                 const int                       arraySize       = (getDataTypeScalarSize(type) > 4 || isDataTypeSampler(type)) ? 3 : 7;
 818
 819                                 vector<UniformInfo> config;
 820
 821                                 UniformInfo                     uniform (VarType(VarType(createVarType(type), arraySize), arraySize),
 822                                                                                          checkStages[stageNdx],
 823                                                                                          checkStages[stageNdx],
 824                                                                                          checkStages[stageNdx],
 825                                                                                          rng.getInt(0, maxLocations-1-arraySize*arraySize));
 826
 827                                 config.push_back(uniform);
 828                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
 829                         }
 830                 }
 831         }
 832
 833         // Structs
 834         {
 835                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "struct", "Struct location, random contents & declaration location");
 836                 de::Random                                      rng             (baseSeed + 0x4001);
 837                 addChild(group);
 838
 839                 for (int caseNdx = 0; caseNdx < 16; caseNdx++)
 840                 {
 841                         typedef UniformInfo::ShaderStage Stage;
 842
 843                         const string    name            = "case_" + de::toString(caseNdx);
 844
 845                         const Stage             layoutLoc       = Stage(rng.getUint32()&0x3);
 846                         const Stage             declareLoc      = Stage((rng.getUint32()&0x3) | layoutLoc);
 847                         const Stage             verifyLoc       = Stage((rng.getUint32()&0x3) & declareLoc);
 848                         const int               location        = layoutLoc ? rng.getInt(0, maxLocations-1-5) : -1;
 849
 850                         StructType*             structProto = new StructType("S");
 851
 852                         structTypes.push_back(structProto);
 853
 854                         structProto->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 855                         structProto->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 856                         structProto->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 857                         structProto->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 858                         structProto->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 859
 860                         {
 861                                 vector<UniformInfo> config;
 862
 863                                 config.push_back(UniformInfo(VarType(structProto),
 864                                                                                          declareLoc,
 865                                                                                          layoutLoc,
 866                                                                                          verifyLoc,
 867                                                                                          location));
 868                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
 869                         }
 870                 }
 871         }
 872
 873         // Nested Structs
 874         {
 875                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "nested_struct", "Struct location specified with use, single shader stage");
 876                 de::Random                                      rng             (baseSeed + 0x5001);
 877
 878                 addChild(group);
 879
 880                 for (int caseNdx = 0; caseNdx < 16; caseNdx++)
 881                 {
 882                         typedef UniformInfo::ShaderStage Stage;
 883
 884                         const string    name            = "case_" + de::toString(caseNdx);
 885                         const int               baseLoc         = rng.getInt(0, maxLocations-1-60);
 886
 887                         // Structs need to be added in the order of their declaration
 888                         const Stage             layoutLocs[]=
 889                         {
 890                                 Stage(rng.getUint32()&0x3),
 891                                 Stage(rng.getUint32()&0x3),
 892                                 Stage(rng.getUint32()&0x3),
 893                                 Stage(rng.getUint32()&0x3),
 894                         };
 895
 896                         const deUint32  tempDecl[] =
 897                         {
 898                                 (rng.getUint32()&0x3) | layoutLocs[0],
 899                                 (rng.getUint32()&0x3) | layoutLocs[1],
 900                                 (rng.getUint32()&0x3) | layoutLocs[2],
 901                                 (rng.getUint32()&0x3) | layoutLocs[3],
 902                         };
 903
 904                         // Component structs need to be declared if anything using them is declared
 905                         const Stage             declareLocs[] =
 906                         {
 907                                 Stage(tempDecl[0] | tempDecl[1] | tempDecl[2] | tempDecl[3]),
 908                                 Stage(tempDecl[1] | tempDecl[2] | tempDecl[3]),
 909                                 Stage(tempDecl[2] | tempDecl[3]),
 910                                 Stage(tempDecl[3]),
 911                         };
 912
 913                         const Stage             verifyLocs[] =
 914                         {
 915                                 Stage(rng.getUint32()&0x3 & declareLocs[0]),
 916                                 Stage(rng.getUint32()&0x3 & declareLocs[1]),
 917                                 Stage(rng.getUint32()&0x3 & declareLocs[2]),
 918                                 Stage(rng.getUint32()&0x3 & declareLocs[3]),
 919                         };
 920
 921                         StructType*             testTypes[]     =
 922                         {
 923                                 new StructType("Type0"),
 924                                 new StructType("Type1"),
 925                                 new StructType("Type2"),
 926                                 new StructType("Type3"),
 927                         };
 928
 929                         structTypes.push_back(testTypes[0]);
 930                         structTypes.push_back(testTypes[1]);
 931                         structTypes.push_back(testTypes[2]);
 932                         structTypes.push_back(testTypes[3]);
 933
 934                         testTypes[0]->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 935                         testTypes[0]->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 936                         testTypes[0]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 937                         testTypes[0]->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 938                         testTypes[0]->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 939
 940                         testTypes[1]->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 941                         testTypes[1]->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 942                         testTypes[1]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 943                         testTypes[1]->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 944                         testTypes[1]->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 945
 946                         testTypes[2]->addMember("a", VarType(testTypes[0]));
 947                         testTypes[2]->addMember("b", VarType(testTypes[1]));
 948                         testTypes[2]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
 949
 950                         testTypes[3]->addMember("a", VarType(testTypes[2]));
 951
 952                         {
 953                                 vector<UniformInfo> config;
 954
 955                                 config.push_back(UniformInfo(VarType(testTypes[0]),
 956                                                                                          declareLocs[0],
 957                                                                                          layoutLocs[0],
 958                                                                                          verifyLocs[0],
 959                                                                                          layoutLocs[0] ? baseLoc : -1));
 960
 961                                 config.push_back(UniformInfo(VarType(testTypes[1]),
 962                                                                                          declareLocs[1],
 963                                                                                          layoutLocs[1],
 964                                                                                          verifyLocs[1],
 965                                                                                          layoutLocs[1] ? baseLoc+5 : -1));
 966
 967                                 config.push_back(UniformInfo(VarType(testTypes[2]),
 968                                                                                          declareLocs[2],
 969                                                                                          layoutLocs[2],
 970                                                                                          verifyLocs[2],
 971                                                                                          layoutLocs[2] ? baseLoc+16 : -1));
 972
 973                                 config.push_back(UniformInfo(VarType(testTypes[3]),
 974                                                                                          declareLocs[3],
 975                                                                                          layoutLocs[3],
 976                                                                                          verifyLocs[3],
 977                                                                                          layoutLocs[3] ? baseLoc+27 : -1));
 978
 979                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
 980                         }
 981                 }
 982         }
 983
 984         // Min/Max location
 985         {
 986                 tcu::TestCaseGroup* const       group           = new tcu::TestCaseGroup(m_testCtx, "min_max", "Maximum & minimum location");
 987
 988                 addChild(group);
 989
 990                 for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
 991                 {
 992                         const DataType          type    = primitiveTypes[primitiveNdx];
 993
 994                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
 995                         {
 996                                 const string            name            = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
 997                                 vector<UniformInfo> config;
 998
 999                                 config.push_back(UniformInfo(createVarType(type),
1000                                                                                          checkStages[stageNdx],
1001                                                                                          checkStages[stageNdx],
1002                                                                                          checkStages[stageNdx],
1003                                                                                          0));
1004
1005                                 group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), (name+"_min").c_str(), (name+"_min").c_str(), config));
1006
1007                                 group->addChild(new MaxUniformLocationCase (m_testCtx, m_context.getRenderContext(), (name+"_max").c_str(), (name+"_max").c_str(), config));
1008                         }
1009                 }
1010         }
1011
1012         // Link
1013         {
1014                 tcu::TestCaseGroup* const       group   = new tcu::TestCaseGroup(m_testCtx, "link", "Location specified independently from use");
1015                 de::Random                                      rng             (baseSeed + 0x82e1);
1016
1017                 addChild(group);
1018
1019                 for (int caseNdx = 0; caseNdx < 10; caseNdx++)
1020                 {
1021                         const string            name            = "case_" + de::toString(caseNdx);
1022                         vector<UniformInfo> config;
1023
1024                         vector<int>                     locations       = shuffledRange(0, maxLocations, 0x1234 + caseNdx*100);
1025
1026                         for (int count = 0; count < 32; count++)
1027                         {
1028                                 typedef UniformInfo::ShaderStage Stage;
1029
1030                                 const Stage                     layoutLoc       = Stage(rng.getUint32()&0x3);
1031                                 const Stage                     declareLoc      = Stage((rng.getUint32()&0x3) | layoutLoc);
1032                                 const Stage                     verifyLoc       = Stage((rng.getUint32()&0x3) & declareLoc);
1033
1034                                 const UniformInfo       uniform         (createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]),
1035                                                                                                  declareLoc,
1036                                                                                                  layoutLoc,
1037                                                                                                  verifyLoc,
1038                                                                                                  (layoutLoc!=0) ? locations.back() : -1);
1039
1040                                 config.push_back(uniform);
1041                                 locations.pop_back();
1042                         }
1043                         group->addChild(new UniformLocationCase (m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
1044                 }
1045         }
1046
1047         // Negative
1048         {
1049                 de::MovePtr<tcu::TestCaseGroup> negativeGroup                   (new tcu::TestCaseGroup(m_testCtx, "negative", "Negative tests"));
1050
1051                 {
1052                         de::MovePtr<tcu::TestCaseGroup> es31Group               (new tcu::TestCaseGroup(m_testCtx, "es31", "GLSL ES 3.1 Negative tests"));
1053                         gls::ShaderLibrary                              shaderLibrary   (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
1054                         const vector<TestNode*>                 negativeCases    = shaderLibrary.loadShaderFile("shaders/es31/uniform_location.test");
1055
1056                         for (int ndx = 0; ndx < int(negativeCases.size()); ndx++)
1057                                 es31Group->addChild(negativeCases[ndx]);
1058
1059                         negativeGroup->addChild(es31Group.release());
1060                 }
1061
1062                 {
1063                         de::MovePtr<tcu::TestCaseGroup> es32Group               (new tcu::TestCaseGroup(m_testCtx, "es32", "GLSL ES 3.2 Negative tests"));
1064                         gls::ShaderLibrary                              shaderLibrary   (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
1065                         const vector<TestNode*>                 negativeCases    = shaderLibrary.loadShaderFile("shaders/es32/uniform_location.test");
1066
1067                         for (int ndx = 0; ndx < int(negativeCases.size()); ndx++)
1068                                 es32Group->addChild(negativeCases[ndx]);
1069
1070                         negativeGroup->addChild(es32Group.release());
1071                 }
1072
1073                 addChild(negativeGroup.release());
1074         }
1075 }
1076
1077 } // Functional
1078 } // gles31
1079 } // deqp