external/openglcts/modules/gles31/es31cProgramInterfaceQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2014-2016 The Khronos Group Inc.
   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
  22  */ /*-------------------------------------------------------------------*/
  23
  24 #include "es31cProgramInterfaceQueryTests.hpp"
  25 #include "glwEnums.hpp"
  26 #include "glwFunctions.hpp"
  27 #include <cstdarg>
  28 #include <map>
  29 #include <set>
  30
  31 namespace glcts
  32 {
  33
  34 using namespace glw;
  35
  36 namespace
  37 {
  38
  39 class PIQBase : public glcts::SubcaseBase
  40 {
  41
  42 public:
  43         virtual ~PIQBase()
  44         {
  45         }
  46
  47         virtual std::string PassCriteria()
  48         {
  49                 return "All called functions return expected values.";
  50         }
  51
  52         virtual std::string Purpose()
  53         {
  54                 return "Verify that the set of tested functions glGetProgram* return\n"
  55                            "expected results when used to get data from program\n"
  56                            "made of " +
  57                            ShadersDesc() + "." + PurposeExt();
  58         }
  59
  60         virtual std::string Method()
  61         {
  62                 return "Create a program using " + ShadersDesc() +
  63                            "\n"
  64                            "then use set of tested functions to get an information about it and\n"
  65                            "verify that information with the expected data" +
  66                            Expectations();
  67         }
  68
  69         virtual long Cleanup()
  70         {
  71                 glUseProgram(0);
  72                 return NO_ERROR;
  73         }
  74
  75         virtual long Setup()
  76         {
  77                 return NO_ERROR;
  78         }
  79
  80 protected:
  81         void LinkProgram(GLuint program)
  82         {
  83                 glLinkProgram(program);
  84                 GLsizei length;
  85                 GLchar  log[1024];
  86                 glGetProgramInfoLog(program, sizeof(log), &length, log);
  87                 if (length > 1)
  88                 {
  89                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
  90                                                                                                 << log << tcu::TestLog::EndMessage;
  91                 }
  92         }
  93
  94         GLuint CreateProgram(const char* src_vs, const char* src_fs, bool link)
  95         {
  96                 const GLuint p = glCreateProgram();
  97
  98                 if (src_vs)
  99                 {
 100                         GLuint sh = glCreateShader(GL_VERTEX_SHADER);
 101                         glAttachShader(p, sh);
 102                         glDeleteShader(sh);
 103                         glShaderSource(sh, 1, &src_vs, NULL);
 104                         glCompileShader(sh);
 105                 }
 106                 if (src_fs)
 107                 {
 108                         GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
 109                         glAttachShader(p, sh);
 110                         glDeleteShader(sh);
 111                         glShaderSource(sh, 1, &src_fs, NULL);
 112                         glCompileShader(sh);
 113                 }
 114                 if (link)
 115                 {
 116                         LinkProgram(p);
 117                 }
 118                 return p;
 119         }
 120
 121         virtual std::string ShadersDesc()
 122         {
 123                 return "";
 124         }
 125
 126         virtual std::string Expectations()
 127         {
 128                 return ".";
 129         }
 130
 131         virtual std::string PurposeExt()
 132         {
 133                 return "";
 134         }
 135
 136         virtual inline void ExpectError(GLenum expected, long& error)
 137         {
 138                 if (error != NO_ERROR)
 139                         return;
 140                 GLenum tmp = glGetError();
 141                 if (tmp == expected)
 142                 {
 143                         m_context.getTestContext().getLog()
 144                                 << tcu::TestLog::Message << "Found expected error" << tcu::TestLog::EndMessage;
 145                         error = NO_ERROR; // Error is expected
 146                 }
 147                 else
 148                 {
 149                         error = ERROR;
 150                         m_context.getTestContext().getLog() << tcu::TestLog::Message << expected
 151                                                                                                 << " error was expected, found: " << tmp << tcu::TestLog::EndMessage;
 152                 }
 153         }
 154
 155         virtual inline void VerifyGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, int expected,
 156                                                                                                         long& error)
 157         {
 158                 GLint res;
 159                 glGetProgramInterfaceiv(program, programInterface, pname, &res);
 160                 if (res != expected)
 161                 {
 162                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
 163                                                                                                 << expected << tcu::TestLog::EndMessage;
 164                         error = ERROR;
 165                 }
 166         }
 167
 168         virtual inline void VerifyGetProgramResourceIndex(GLuint program, GLenum programInterface, const std::string& name,
 169                                                                                                           GLuint expected, long& error)
 170         {
 171                 GLuint res = glGetProgramResourceIndex(program, programInterface, name.c_str());
 172                 if (res != expected)
 173                 {
 174                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
 175                                                                                                 << expected << tcu::TestLog::EndMessage;
 176                         error = ERROR;
 177                 }
 178         }
 179
 180         virtual inline void VerifyGetProgramResourceIndex(GLuint program, GLenum                 programInterface,
 181                                                                                                           std::map<std::string, GLuint>& indices, const std::string& name,
 182                                                                                                           long& error)
 183         {
 184                 GLuint res = glGetProgramResourceIndex(program, programInterface, name.c_str());
 185                 if (res == GL_INVALID_INDEX)
 186                 {
 187                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res
 188                                                                                                 << ", expected number other than -1" << tcu::TestLog::EndMessage;
 189                         error = ERROR;
 190                         return;
 191                 }
 192                 std::map<std::string, GLuint>::iterator it = indices.begin();
 193                 while (it != indices.end())
 194                 {
 195                         if (it->second == res)
 196                         {
 197                                 m_context.getTestContext().getLog()
 198                                         << tcu::TestLog::Message << "ERROR: Duplicated value found: " << res << tcu::TestLog::EndMessage;
 199                                 error = ERROR;
 200                                 return;
 201                         }
 202                         ++it;
 203                 }
 204                 indices[name] = res;
 205         }
 206
 207         virtual inline void VerifyGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index,
 208                                                                                                          const std::string& expected, long& error)
 209         {
 210                 GLchar  name[1024] = { '\0' };
 211                 GLsizei len;
 212                 glGetProgramResourceName(program, programInterface, index, 1024, &len, name);
 213                 if (len <= 0 || len > 1023 || name[len - 1] == '\0')
 214                 {
 215                         m_context.getTestContext().getLog()
 216                                 << tcu::TestLog::Message
 217                                 << "ERROR: Length in glGetProgramResourceName should not count null terminator!"
 218                                 << tcu::TestLog::EndMessage;
 219                         error = ERROR;
 220                 }
 221                 else if (name != expected || name[len] != '\0')
 222                 {
 223                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << name << ", expected "
 224                                                                                                 << expected << tcu::TestLog::EndMessage;
 225                         error = ERROR;
 226                 }
 227         }
 228
 229         virtual inline void VerifyGetProgramResourceLocation(GLuint program, GLenum programInterface,
 230                                                                                                                  const std::string& name, GLint expected, long& error)
 231         {
 232                 GLint res = glGetProgramResourceLocation(program, programInterface, name.c_str());
 233                 if (res != expected)
 234                 {
 235                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
 236                                                                                                 << expected << tcu::TestLog::EndMessage;
 237                         error = ERROR;
 238                 }
 239         }
 240
 241         virtual inline void VerifyGetProgramResourceLocation(GLuint program, GLenum                programInterface,
 242                                                                                                                  std::map<std::string, GLint>& locations,
 243                                                                                                                  const std::string& name, long& error)
 244         {
 245                 GLint res = glGetProgramResourceLocation(program, programInterface, name.c_str());
 246                 if (res < 0)
 247                 {
 248                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res
 249                                                                                                 << ", expected not less than 0" << tcu::TestLog::EndMessage;
 250                         error = ERROR;
 251                         return;
 252                 }
 253                 std::map<std::string, GLint>::iterator it = locations.begin();
 254                 while (it != locations.end())
 255                 {
 256                         if (it->second == res)
 257                         {
 258                                 m_context.getTestContext().getLog()
 259                                         << tcu::TestLog::Message << "ERROR: Duplicated value found: " << res << tcu::TestLog::EndMessage;
 260                                 error = ERROR;
 261                                 return;
 262                         }
 263                         ++it;
 264                 }
 265                 locations[name] = res;
 266         }
 267
 268         virtual inline void VerifyGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index,
 269                                                                                                    GLsizei propCount, const GLenum props[], GLsizei expectedLength,
 270                                                                                                    const GLint expected[], long& error)
 271         {
 272                 const GLsizei bufSize = 1000;
 273                 GLsizei           length;
 274                 GLint             params[bufSize];
 275                 glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, &length, params);
 276                 if (length != expectedLength || length <= 0)
 277                 {
 278                         error = ERROR;
 279                         m_context.getTestContext().getLog()
 280                                 << tcu::TestLog::Message << "ERROR: Got length " << length << ", expected " << expectedLength
 281                                 << "\nCALL: glGetProgramResourceiv, with " << programInterface << ", " << index
 282                                 << tcu::TestLog::EndMessage;
 283                         return;
 284                 }
 285                 for (int i = 0; i < length; ++i)
 286                 {
 287                         if (params[i] != expected[i])
 288                         {
 289                                 error = ERROR;
 290                                 m_context.getTestContext().getLog()
 291                                         << tcu::TestLog::Message << "ERROR: Got " << params[i] << ", expected " << expected[i]
 292                                         << " at: " << i << "\nCALL: glGetProgramResourceiv, with " << programInterface << ", " << index
 293                                         << tcu::TestLog::EndMessage;
 294                         }
 295                 }
 296         }
 297
 298         virtual inline GLint GetProgramivRetValue(GLuint program, GLenum pname)
 299         {
 300                 GLint ret;
 301                 glGetProgramiv(program, pname, &ret);
 302                 return ret;
 303         }
 304
 305         static const GLenum interfaces[];
 306 };
 307
 308 const GLenum PIQBase::interfaces[] = { GL_PROGRAM_INPUT,
 309                                                                            GL_PROGRAM_OUTPUT,
 310                                                                            GL_UNIFORM,
 311                                                                            GL_UNIFORM_BLOCK,
 312                                                                            GL_BUFFER_VARIABLE,
 313                                                                            GL_SHADER_STORAGE_BLOCK,
 314                                                                            GL_ATOMIC_COUNTER_BUFFER,
 315                                                                            GL_TRANSFORM_FEEDBACK_VARYING };
 316
 317 class NoShaders : public PIQBase
 318 {
 319
 320         virtual std::string Title()
 321         {
 322                 return "No Shaders Test";
 323         }
 324
 325         virtual std::string ShadersDesc()
 326         {
 327                 return "no shaders";
 328         }
 329
 330         virtual long Run()
 331         {
 332                 const GLuint program = glCreateProgram();
 333
 334                 long error = NO_ERROR;
 335                 int  size  = sizeof(PIQBase::interfaces) / sizeof(PIQBase::interfaces[0]);
 336
 337                 for (int i = 0; i < size; ++i)
 338                 {
 339                         VerifyGetProgramInterfaceiv(program, PIQBase::interfaces[i], GL_ACTIVE_RESOURCES, 0, error);
 340                         if (PIQBase::interfaces[i] == GL_ATOMIC_COUNTER_BUFFER)
 341                                 continue;
 342                         VerifyGetProgramInterfaceiv(program, PIQBase::interfaces[i], GL_MAX_NAME_LENGTH, 0, error);
 343                 }
 344                 VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);
 345                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);
 346                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);
 347
 348                 for (int i = 0; i < size; ++i)
 349                 {
 350                         if (PIQBase::interfaces[i] == GL_ATOMIC_COUNTER_BUFFER)
 351                                 continue;
 352                         VerifyGetProgramResourceIndex(program, PIQBase::interfaces[i], "", GL_INVALID_INDEX, error);
 353                 }
 354
 355                 // can't test GetProgramResourceLocation* here since program has to be linked
 356                 // can't test GetProgramResourceiv, need valid index
 357
 358                 glDeleteProgram(program);
 359                 return error;
 360         }
 361 };
 362
 363 class SimpleShaders : public PIQBase
 364 {
 365
 366 public:
 367         virtual std::string Title()
 368         {
 369                 return "Simple Shaders Test";
 370         }
 371
 372         virtual std::string ShadersDesc()
 373         {
 374                 return "fallthrough fragment and vertex shaders";
 375         }
 376
 377         virtual std::string VertexShader()
 378         {
 379                 return "#version 310 es                      \n"
 380                            "in vec4 position;                    \n"
 381                            "void main(void)                      \n"
 382                            "{                                    \n"
 383                            "    gl_Position = position;          \n"
 384                            "}";
 385         }
 386
 387         virtual std::string FragmentShader()
 388         {
 389                 return "#version 310 es                \n"
 390                            "out mediump vec4 color;        \n"
 391                            "void main() {                  \n"
 392                            "    color = vec4(0, 1, 0, 1);  \n"
 393                            "}";
 394         }
 395
 396         virtual long Run()
 397         {
 398                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
 399                 glBindAttribLocation(program, 0, "position");
 400                 glLinkProgram(program);
 401
 402                 long error = NO_ERROR;
 403
 404                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
 405                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
 406                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
 407                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 6, error);
 408
 409                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color", 0, error);
 410                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "position", 0, error);
 411
 412                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, "color", error);
 413                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, "position", error);
 414
 415                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", 0, error);
 416                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", 0, error);
 417
 418                 GLenum props[] = { GL_NAME_LENGTH,
 419                                                    GL_TYPE,
 420                                                    GL_ARRAY_SIZE,
 421                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
 422                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
 423                                                    GL_REFERENCED_BY_VERTEX_SHADER,
 424                                                    GL_LOCATION };
 425                 GLint expected[] = { 9, 35666, 1, 0, 0, 1, 0 };
 426                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 7, props, 7, expected, error);
 427
 428                 GLenum props2[] = { GL_NAME_LENGTH,
 429                                                         GL_TYPE,
 430                                                         GL_ARRAY_SIZE,
 431                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
 432                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
 433                                                         GL_REFERENCED_BY_VERTEX_SHADER,
 434                                                         GL_LOCATION };
 435                 GLint expected2[] = { 6, 35666, 1, 0, 1, 0, 0 };
 436                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, 0, 7, props2, 7, expected2, error);
 437
 438                 glDeleteProgram(program);
 439                 return error;
 440         }
 441 };
 442
 443 class ComputeShaderTest : public PIQBase
 444 {
 445 public:
 446         virtual std::string Title()
 447         {
 448                 return "Compute Shader Test";
 449         }
 450
 451         virtual std::string ShadersDesc()
 452         {
 453                 return "compute shader";
 454         }
 455
 456         virtual std::string ComputeShader()
 457         {
 458                 return "layout(local_size_x = 1, local_size_y = 1) in; \n"
 459                            "layout(std430) buffer Output {                 \n"
 460                            "  mediump vec4 data[];                         \n"
 461                            "} g_out;                                       \n"
 462                            ""
 463                            "void main() {                                   \n"
 464                            "   g_out.data[0] = vec4(1.0, 2.0, 3.0, 4.0);    \n"
 465                            "   g_out.data[100] = vec4(1.0, 2.0, 3.0, 4.0);  \n"
 466                            "}";
 467         }
 468
 469         GLuint CreateComputeProgram(const std::string& cs)
 470         {
 471                 const GLuint p = glCreateProgram();
 472
 473                 const char* const kGLSLVer = "#version 310 es\n";
 474
 475                 if (!cs.empty())
 476                 {
 477                         const GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
 478                         glAttachShader(p, sh);
 479                         glDeleteShader(sh);
 480                         const char* const src[2] = { kGLSLVer, cs.c_str() };
 481                         glShaderSource(sh, 2, src, NULL);
 482                         glCompileShader(sh);
 483                 }
 484
 485                 return p;
 486         }
 487
 488         bool CheckProgram(GLuint program, bool* compile_error = NULL)
 489         {
 490                 GLint compile_status = GL_TRUE;
 491                 GLint status;
 492                 glGetProgramiv(program, GL_LINK_STATUS, &status);
 493
 494                 if (status == GL_FALSE)
 495                 {
 496                         GLint attached_shaders;
 497                         glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
 498
 499                         if (attached_shaders > 0)
 500                         {
 501                                 std::vector<GLuint> shaders(attached_shaders);
 502                                 glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]);
 503
 504                                 for (GLint i = 0; i < attached_shaders; ++i)
 505                                 {
 506                                         GLenum type;
 507                                         glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type));
 508                                         switch (type)
 509                                         {
 510                                         case GL_VERTEX_SHADER:
 511                                                 m_context.getTestContext().getLog()
 512                                                         << tcu::TestLog::Message << "*** Vertex Shader ***" << tcu::TestLog::EndMessage;
 513                                                 break;
 514                                         case GL_TESS_CONTROL_SHADER:
 515                                                 m_context.getTestContext().getLog()
 516                                                         << tcu::TestLog::Message << "*** Tessellation Control Shader ***"
 517                                                         << tcu::TestLog::EndMessage;
 518                                                 break;
 519                                         case GL_TESS_EVALUATION_SHADER:
 520                                                 m_context.getTestContext().getLog()
 521                                                         << tcu::TestLog::Message << "*** Tessellation Evaluation Shader ***"
 522                                                         << tcu::TestLog::EndMessage;
 523                                                 break;
 524                                         case GL_GEOMETRY_SHADER:
 525                                                 m_context.getTestContext().getLog()
 526                                                         << tcu::TestLog::Message << "*** Geometry Shader ***" << tcu::TestLog::EndMessage;
 527                                                 break;
 528                                         case GL_FRAGMENT_SHADER:
 529                                                 m_context.getTestContext().getLog()
 530                                                         << tcu::TestLog::Message << "*** Fragment Shader ***" << tcu::TestLog::EndMessage;
 531                                                 break;
 532                                         case GL_COMPUTE_SHADER:
 533                                                 m_context.getTestContext().getLog()
 534                                                         << tcu::TestLog::Message << "*** Compute Shader ***" << tcu::TestLog::EndMessage;
 535                                                 break;
 536                                         default:
 537                                                 m_context.getTestContext().getLog()
 538                                                         << tcu::TestLog::Message << "*** Unknown Shader ***" << tcu::TestLog::EndMessage;
 539                                         }
 540
 541                                         GLint res;
 542                                         glGetShaderiv(shaders[i], GL_COMPILE_STATUS, &res);
 543                                         if (res != GL_TRUE)
 544                                                 compile_status = res;
 545
 546                                         // shader source
 547                                         GLint length;
 548                                         glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length);
 549                                         if (length > 0)
 550                                         {
 551                                                 std::vector<GLchar> source(length);
 552                                                 glGetShaderSource(shaders[i], length, NULL, &source[0]);
 553                                                 m_context.getTestContext().getLog()
 554                                                         << tcu::TestLog::Message << &source[0] << tcu::TestLog::EndMessage;
 555                                         }
 556
 557                                         // shader info log
 558                                         glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length);
 559                                         if (length > 0)
 560                                         {
 561                                                 std::vector<GLchar> log(length);
 562                                                 glGetShaderInfoLog(shaders[i], length, NULL, &log[0]);
 563                                                 m_context.getTestContext().getLog()
 564                                                         << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
 565                                         }
 566                                 }
 567                         }
 568
 569                         // program info log
 570                         GLint length;
 571                         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
 572                         if (length > 0)
 573                         {
 574                                 std::vector<GLchar> log(length);
 575                                 glGetProgramInfoLog(program, length, NULL, &log[0]);
 576                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
 577                         }
 578                 }
 579
 580                 if (compile_error)
 581                         *compile_error = (compile_status == GL_TRUE ? false : true);
 582                 if (compile_status != GL_TRUE)
 583                         return false;
 584                 return status == GL_TRUE ? true : false;
 585         }
 586
 587         virtual void inline VerifyCompute(GLuint program, long& error)
 588         {
 589                 VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 15, error);
 590                 VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_ACTIVE_RESOURCES, 1, error);
 591                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 1, error);
 592                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 7, error);
 593                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 1, error);
 594
 595                 std::map<std::string, GLuint> indicesSSB;
 596                 std::map<std::string, GLuint> indicesBV;
 597                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "Output", error);
 598                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "Output.data", error);
 599
 600                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Output"], "Output", error);
 601                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["Outputa.data"], "Output.data[0]", error);
 602
 603                 GLenum props3[] = { GL_NAME_LENGTH,
 604                                                         GL_BUFFER_BINDING,
 605                                                         GL_NUM_ACTIVE_VARIABLES,
 606                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
 607                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
 608                                                         GL_REFERENCED_BY_VERTEX_SHADER,
 609                                                         GL_ACTIVE_VARIABLES };
 610                 GLint expected3[] = { 7, 0, 1, 1, 0, 0, static_cast<GLint>(indicesBV["Outputa.data"]) };
 611                 VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Output"], 7, props3, 7, expected3,
 612                                                                    error);
 613
 614                 GLenum props4[] = { GL_NAME_LENGTH,
 615                                                         GL_TYPE,
 616                                                         GL_ARRAY_SIZE,
 617                                                         GL_BLOCK_INDEX,
 618                                                         GL_IS_ROW_MAJOR,
 619                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
 620                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
 621                                                         GL_REFERENCED_BY_VERTEX_SHADER,
 622                                                         GL_TOP_LEVEL_ARRAY_SIZE };
 623                 GLint expected4[] = { 15, 35666, 0, static_cast<GLint>(indicesSSB["Output"]), 0, 1, 0, 0, 1 };
 624                 VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["Outputa.data"], 9, props4, 9, expected4,
 625                                                                    error);
 626         }
 627
 628         virtual long Run()
 629         {
 630                 GLuint program = CreateComputeProgram(ComputeShader());
 631                 glLinkProgram(program);
 632                 if (!CheckProgram(program))
 633                 {
 634                         glDeleteProgram(program);
 635                         return ERROR;
 636                 }
 637                 glUseProgram(program);
 638
 639                 long error = NO_ERROR;
 640
 641                 VerifyCompute(program, error);
 642
 643                 glDeleteProgram(program);
 644                 return error;
 645         }
 646 };
 647
 648 class InputTypes : public SimpleShaders
 649 {
 650         virtual std::string Title()
 651         {
 652                 return "Input Types Test";
 653         }
 654
 655         virtual std::string ShadersDesc()
 656         {
 657                 return "vertex shader with different `in` types and a fallthrough fragment shader";
 658         }
 659
 660         virtual std::string VertexShader()
 661         {
 662                 return "#version 310 es                      \n"
 663                            "in mat4 a;                           \n"
 664                            "in vec4 b;                           \n"
 665                            "in float c;                          \n"
 666                            "in mat2x3 d;                         \n"
 667                            "in vec2 e;                           \n"
 668                            "in uint f;                           \n"
 669                            "in vec3 g;                           \n"
 670                            "in int h;                            \n"
 671                            "void main(void)                      \n"
 672                            "{                                    \n"
 673                            "   vec4 pos;                                                 \n"
 674                            "   pos.w = float(h) + g.x + g.y + d[1].y;                    \n"
 675                            "   pos.y = float(b.x) * c + c + d[0][0];                     \n"
 676                            "   pos.x = a[0].x + a[1].y + a[2].z + a[3].w;                \n"
 677                            "   pos.z = d[0][1] + float(e.x) * float(f) + d[1][0];        \n"
 678                            "   gl_Position = pos;                                        \n"
 679                            "}";
 680         }
 681
 682         virtual long Run()
 683         {
 684                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
 685                 glBindAttribLocation(program, 0, "a");
 686                 glBindAttribLocation(program, 4, "b");
 687                 glBindAttribLocation(program, 5, "c");
 688                 glBindAttribLocation(program, 7, "d");
 689                 glBindAttribLocation(program, 11, "e");
 690                 glBindAttribLocation(program, 12, "f");
 691                 glBindAttribLocation(program, 13, "g");
 692                 glBindAttribLocation(program, 15, "h");
 693                 LinkProgram(program);
 694
 695                 long error = NO_ERROR;
 696
 697                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 8, error);
 698                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);
 699
 700                 std::map<std::string, GLuint> indices;
 701                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "a", error);
 702                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "b", error);
 703                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "c", error);
 704                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "d", error);
 705                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "e", error);
 706                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "f", error);
 707                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "g", error);
 708                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "h", error);
 709
 710                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["a"], "a", error);
 711                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["b"], "b", error);
 712                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["c"], "c", error);
 713                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["d"], "d", error);
 714                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["e"], "e", error);
 715                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["f"], "f", error);
 716                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["g"], "g", error);
 717                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["h"], "h", error);
 718
 719                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "a", 0, error);
 720                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "b", 4, error);
 721                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "c", 5, error);
 722                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "d", 7, error);
 723                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "e", 11, error);
 724                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "f", 12, error);
 725                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "g", 13, error);
 726                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "h", 15, error);
 727
 728                 GLenum props[] = {
 729                         GL_NAME_LENGTH,
 730                         GL_TYPE,
 731                         GL_ARRAY_SIZE,
 732                         GL_REFERENCED_BY_COMPUTE_SHADER,
 733                         GL_REFERENCED_BY_FRAGMENT_SHADER,
 734                         GL_REFERENCED_BY_VERTEX_SHADER,
 735                         GL_LOCATION,
 736                 };
 737                 GLint expected[] = { 2, 35676, 1, 0, 0, 1, 0 };
 738                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["a"], 7, props, 7, expected, error);
 739                 GLint expected2[] = { 2, 35666, 1, 0, 0, 1, 4 };
 740                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["b"], 7, props, 7, expected2, error);
 741                 GLint expected3[] = { 2, 5126, 1, 0, 0, 1, 5 };
 742                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["c"], 7, props, 7, expected3, error);
 743                 GLint expected4[] = { 2, 35685, 1, 0, 0, 1, 7 };
 744                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["d"], 7, props, 7, expected4, error);
 745                 GLint expected5[] = { 2, 35664, 1, 0, 0, 1, 11 };
 746                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["e"], 7, props, 7, expected5, error);
 747                 GLint expected6[] = { 2, 5125, 1, 0, 0, 1, 12 };
 748                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["f"], 7, props, 7, expected6, error);
 749                 GLint expected7[] = { 2, 35665, 1, 0, 0, 1, 13 };
 750                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["g"], 7, props, 7, expected7, error);
 751                 GLint expected8[] = { 2, 5124, 1, 0, 0, 1, 15 };
 752                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["h"], 7, props, 7, expected8, error);
 753
 754                 glDeleteProgram(program);
 755                 return error;
 756         }
 757 };
 758
 759 class InputBuiltIn : public SimpleShaders
 760 {
 761
 762         virtual std::string Title()
 763         {
 764                 return "Input Built-ins Test";
 765         }
 766
 767         virtual std::string ShadersDesc()
 768         {
 769                 return "vertex shader using built-in variables and a fallthrough fragment shader";
 770         }
 771
 772         virtual std::string Expectations()
 773         {
 774                 return ".\n\n In this case we ask for information about built-in variables for the input interface.";
 775         }
 776
 777         virtual std::string VertexShader()
 778         {
 779                 return "#version 310 es                      \n"
 780                            "void main(void)                      \n"
 781                            "{                                    \n"
 782                            "    gl_Position = (float(gl_VertexID) + float(gl_InstanceID)) * vec4(0.1);          \n"
 783                            "}";
 784         }
 785
 786         virtual long Run()
 787         {
 788                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
 789                 LinkProgram(program);
 790
 791                 long error = NO_ERROR;
 792
 793                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 2, error);
 794                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 14, error);
 795
 796                 std::map<std::string, GLuint> indices;
 797                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "gl_VertexID", error);
 798                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "gl_InstanceID", error);
 799
 800                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["gl_VertexID"], "gl_VertexID", error);
 801                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["gl_InstanceID"], "gl_InstanceID", error);
 802
 803                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "gl_VertexID", -1, error);
 804                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "gl_InstanceID", -1, error);
 805
 806                 GLenum props[] = { GL_NAME_LENGTH,
 807                                                    GL_TYPE,
 808                                                    GL_ARRAY_SIZE,
 809                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
 810                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
 811                                                    GL_REFERENCED_BY_VERTEX_SHADER,
 812                                                    GL_LOCATION };
 813                 GLint expected[] = { 12, 5124, 1, 0, 0, 1, -1 };
 814                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["gl_VertexID"], 7, props, 7, expected, error);
 815                 GLint expected2[] = { 14, 5124, 1, 0, 0, 1, -1 };
 816                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["gl_InstanceID"], 7, props, 7, expected2, error);
 817
 818                 glDeleteProgram(program);
 819                 return error;
 820         }
 821 };
 822
 823 class InputLayout : public SimpleShaders
 824 {
 825         virtual std::string Title()
 826         {
 827                 return "Input Layout Test";
 828         }
 829
 830         virtual std::string ShadersDesc()
 831         {
 832                 return "vertex shader with different `in` variables locations set through layout and a fallthrough fragment "
 833                            "shader";
 834         }
 835
 836         virtual std::string VertexShader()
 837         {
 838                 return "#version 310 es                      \n"
 839                            "layout(location = 4) in vec4 b;      \n"
 840                            "layout(location = 7) in mat2x3 d;    \n"
 841                            "layout(location = 5) in float c;     \n"
 842                            "layout(location = 12) in uint f;     \n"
 843                            "layout(location = 13) in vec3 g;     \n"
 844                            "layout(location = 0) in mat4 a;      \n"
 845                            "layout(location = 15) in int h;      \n"
 846                            "layout(location = 11) in vec2 e;     \n"
 847                            "void main(void)                      \n"
 848                            "{                                    \n"
 849                            "   vec4 pos;                                              \n"
 850                            "   pos.w = float(h) + g.x + g.y + d[1][1];                \n"
 851                            "   pos.y = float(b.x) * c + c + d[0][0];                  \n"
 852                            "   pos.x = a[0].x + a[1].y + a[2].z + a[3].w;             \n"
 853                            "   pos.z = d[0][1] + float(e.x) * float(f) + d[1][0];     \n"
 854                            "   gl_Position = pos;                                     \n"
 855                            "}";
 856         }
 857
 858         virtual long Run()
 859         {
 860                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
 861                 LinkProgram(program);
 862
 863                 long error = NO_ERROR;
 864
 865                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 8, error);
 866                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);
 867
 868                 std::map<std::string, GLuint> indices;
 869                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "a", error);
 870                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "b", error);
 871                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "c", error);
 872                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "d", error);
 873                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "e", error);
 874                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "f", error);
 875                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "g", error);
 876                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "h", error);
 877
 878                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["a"], "a", error);
 879                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["b"], "b", error);
 880                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["c"], "c", error);
 881                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["d"], "d", error);
 882                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["e"], "e", error);
 883                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["f"], "f", error);
 884                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["g"], "g", error);
 885                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["h"], "h", error);
 886
 887                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "a", 0, error);
 888                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "b", 4, error);
 889                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "c", 5, error);
 890                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "d", 7, error);
 891                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "e", 11, error);
 892                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "f", 12, error);
 893                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "g", 13, error);
 894                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "h", 15, error);
 895
 896                 GLenum props[] = { GL_NAME_LENGTH,
 897                                                    GL_TYPE,
 898                                                    GL_ARRAY_SIZE,
 899                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
 900                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
 901                                                    GL_REFERENCED_BY_VERTEX_SHADER,
 902                                                    GL_LOCATION };
 903                 GLint expected[] = { 2, 35676, 1, 0, 0, 1, 0 };
 904                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["a"], 7, props, 7, expected, error);
 905                 GLint expected2[] = { 2, 35666, 1, 0, 0, 1, 4 };
 906                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["b"], 7, props, 7, expected2, error);
 907                 GLint expected3[] = { 2, 5126, 1, 0, 0, 1, 5 };
 908                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["c"], 7, props, 7, expected3, error);
 909                 GLint expected4[] = { 2, 35685, 1, 0, 0, 1, 7 };
 910                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["d"], 7, props, 7, expected4, error);
 911                 GLint expected5[] = { 2, 35664, 1, 0, 0, 1, 11 };
 912                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["e"], 7, props, 7, expected5, error);
 913                 GLint expected6[] = { 2, 5125, 1, 0, 0, 1, 12 };
 914                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["f"], 7, props, 7, expected6, error);
 915                 GLint expected7[] = { 2, 35665, 1, 0, 0, 1, 13 };
 916                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["g"], 7, props, 7, expected7, error);
 917                 GLint expected8[] = { 2, 5124, 1, 0, 0, 1, 15 };
 918                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["h"], 7, props, 7, expected8, error);
 919
 920                 glDeleteProgram(program);
 921                 return error;
 922         }
 923 };
 924
 925 class OutputLayout : public SimpleShaders
 926 {
 927         virtual std::string Title()
 928         {
 929                 return "Output Layout Test";
 930         }
 931
 932         virtual std::string ShadersDesc()
 933         {
 934                 return "fragment shader with different `out` variables locations set through layout and a fallthrough vertex "
 935                            "shader";
 936         }
 937
 938         virtual std::string FragmentShader()
 939         {
 940                 return "#version 310 es                \n"
 941                            "layout(location = 2) out uint b;                    \n"
 942                            "layout(location = 3) out mediump vec2 e;            \n"
 943                            "layout(location = 0) out mediump vec3 a[2];         \n"
 944                            "void main() {                  \n"
 945                            "    b = 12u;                   \n"
 946                            "    e = vec2(0, 1);            \n"
 947                            "    a[1] = vec3(0, 1, 0);      \n"
 948                            "    a[0] = vec3(0, 1, 0);      \n"
 949                            "}";
 950         }
 951
 952         virtual long Run()
 953         {
 954                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
 955                 glBindAttribLocation(program, 0, "position");
 956                 LinkProgram(program);
 957
 958                 long error = NO_ERROR;
 959
 960                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 3, error);
 961                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 5, error);
 962
 963                 std::map<std::string, GLuint> indices;
 964                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "a", error);
 965                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "b", error);
 966                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "e", error);
 967
 968                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["a"], "a[0]", error);
 969                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["b"], "b", error);
 970                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["e"], "e", error);
 971
 972                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a[0]", 0, error);
 973                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a", 0, error);
 974                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a[1]", 1, error);
 975                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "b", 2, error);
 976                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "e", 3, error);
 977
 978                 GLenum props[] = { GL_NAME_LENGTH,
 979                                                    GL_TYPE,
 980                                                    GL_ARRAY_SIZE,
 981                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
 982                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
 983                                                    GL_REFERENCED_BY_VERTEX_SHADER,
 984                                                    GL_LOCATION };
 985                 GLint expected_a[] = { 5, 35665, 2, 0, 1, 0, 0 };
 986                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["a"], 7, props, 7, expected_a, error);
 987                 GLint expected_b[] = { 2, 5125, 1, 0, 1, 0, 2 };
 988                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["b"], 7, props, 7, expected_b, error);
 989                 GLint expected_e[] = { 2, 35664, 1, 0, 1, 0, 3 };
 990                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["e"], 7, props, 7, expected_e, error);
 991
 992                 glDeleteProgram(program);
 993                 return error;
 994         }
 995 };
 996
 997 class UniformSimple : public PIQBase
 998 {
 999         virtual std::string Title()
1000         {
1001                 return "Uniform Simple Test";
1002         }
1003
1004         virtual std::string ShadersDesc()
1005         {
1006                 return "fallthrough fragment and vertex shaders with uniforms used";
1007         }
1008
1009         virtual std::string PurposeExt()
1010         {
1011                 return "\n\n Purpose is to verify calls using GL_UNIFORM as an interface param.";
1012         }
1013
1014         virtual std::string VertexShader()
1015         {
1016                 return "#version 310 es                      \n"
1017                            "in vec4 position;                    \n"
1018                            "uniform mediump vec4 repos;          \n"
1019                            "void main(void)                      \n"
1020                            "{                                    \n"
1021                            "    gl_Position = position + repos;  \n"
1022                            "}";
1023         }
1024
1025         virtual std::string FragmentShader()
1026         {
1027                 return "#version 310 es                \n"
1028                            "uniform mediump vec4 recolor;  \n"
1029                            "out mediump vec4 color;        \n"
1030                            "void main() {                  \n"
1031                            "    color = vec4(0, 1, 0, 1) + recolor;  \n"
1032                            "}";
1033         }
1034
1035         virtual long Run()
1036         {
1037                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
1038                 glBindAttribLocation(program, 0, "position");
1039                 LinkProgram(program);
1040
1041                 long error = NO_ERROR;
1042
1043                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
1044                                                                         GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
1045                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 8, error);
1046
1047                 std::map<std::string, GLuint> indices;
1048                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "repos", error);
1049                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "recolor", error);
1050
1051                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["repos"], "repos", error);
1052                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["recolor"], "recolor", error);
1053
1054                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "repos", glGetUniformLocation(program, "repos"), error);
1055                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "recolor", glGetUniformLocation(program, "recolor"),
1056                                                                                  error);
1057
1058                 GLenum props[] = { GL_NAME_LENGTH,
1059                                                    GL_TYPE,
1060                                                    GL_ARRAY_SIZE,
1061                                                    GL_OFFSET,
1062                                                    GL_BLOCK_INDEX,
1063                                                    GL_ARRAY_STRIDE,
1064                                                    GL_MATRIX_STRIDE,
1065                                                    GL_IS_ROW_MAJOR,
1066                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
1067                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
1068                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
1069                                                    GL_REFERENCED_BY_VERTEX_SHADER,
1070                                                    GL_LOCATION };
1071                 GLint expected[] = { 6, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "repos") };
1072                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["repos"], 13, props, 13, expected, error);
1073
1074                 GLint expected2[] = { 8, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "recolor") };
1075                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["recolor"], 13, props, 13, expected2, error);
1076
1077                 glDeleteProgram(program);
1078                 return error;
1079         }
1080 };
1081
1082 class UniformTypes : public PIQBase
1083 {
1084         virtual std::string Title()
1085         {
1086                 return "Uniform Types Test";
1087         }
1088
1089         virtual std::string ShadersDesc()
1090         {
1091                 return "fallthrough fragment and vertex shaders with different uniform types used";
1092         }
1093
1094         virtual std::string PurposeExt()
1095         {
1096                 return "\n\n Purpose is to verify calls using GL_UNIFORM as an interface param.\n";
1097         }
1098
1099         virtual std::string VertexShader()
1100         {
1101                 return "#version 310 es                      \n"
1102                            "in vec4 position;                    \n"
1103                            "uniform mediump vec4 a;              \n"
1104                            "uniform ivec3 b;                     \n"
1105                            "uniform uvec2 c[3];                  \n"
1106                            "uniform mediump mat2 g[8];           \n"
1107                            "uniform mediump mat3x2 i;            \n"
1108                            "void main(void)                      \n"
1109                            "{                                    \n"
1110                            "    float tmp;                       \n"
1111                            "    tmp = g[0][1][1] * g[1][0][0] + g[2][1][0] - g[3][0][1]; \n"
1112                            "    tmp = tmp + g[4][0][0] * g[5][1][0] - g[6][1][1] + g[7][0][1]; \n"
1113                            "    tmp = tmp + a.z + +float(b.y) + float(c[0].x) - float(c[1].x) * float(c[2].y);   \n"
1114                            "    tmp = tmp + i[1][1];             \n"
1115                            "    gl_Position = position * tmp;    \n"
1116                            "}";
1117         }
1118
1119         virtual std::string FragmentShader()
1120         {
1121                 return "#version 310 es                \n"
1122                            "struct U {                     \n"
1123                            "   bool a[3];                  \n"
1124                            "   mediump vec4 b;                     \n"
1125                            "   mediump mat3 c;                     \n"
1126                            "   mediump float d[2];                 \n"
1127                            "};                             \n"
1128                            "struct UU {                    \n"
1129                            "   U a;                        \n"
1130                            "   U b[2];                     \n"
1131                            "   uvec2 c;                    \n"
1132                            "};                             \n"
1133                            "uniform mediump mat4 d;                \n"
1134                            "uniform mediump mat3 e;                \n"
1135                            "uniform mediump float h;               \n"
1136                            "uniform int f;                 \n"
1137                            "uniform U j;                   \n"
1138                            "uniform UU k;                  \n"
1139                            "uniform UU l[3];               \n"
1140                            "out mediump vec4 color;                \n"
1141                            "void main() {                  \n"
1142                            "    mediump float tmp;                 \n"
1143                            "    tmp = h + float(f) + e[2][2];           \n"
1144                            "    tmp = tmp + d[0][0] + j.b.x;     \n"
1145                            "    tmp = tmp + k.b[0].c[0][0];      \n"
1146                            "    tmp = tmp + l[2].a.c[0][1];      \n"
1147                            "    tmp = tmp + l[2].b[1].d[0];      \n"
1148                            "    tmp = tmp + float(l[0].c.x);            \n"
1149                            "    color = vec4(0, 1, 0, 1) * tmp;  \n"
1150                            "}";
1151         }
1152
1153         virtual long Run()
1154         {
1155                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
1156                 glBindAttribLocation(program, 0, "position");
1157                 LinkProgram(program);
1158
1159                 long error = NO_ERROR;
1160
1161                 // only active structure members
1162                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
1163                                                                         GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
1164                 // l[2].b[1].d[0] and \0
1165                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 15, error);
1166
1167                 std::map<std::string, GLuint> indices;
1168                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "a", error);
1169                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "b", error);
1170                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "c", error);
1171                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "d", error);
1172                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "e", error);
1173                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "f", error);
1174                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "g", error);
1175                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "h", error);
1176                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "i", error);
1177                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "j.b", error);
1178                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "k.b[0].c", error);
1179                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[0].c", error);
1180                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[2].b[1].d[0]", error);
1181                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[2].a.c", error);
1182
1183                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["a"], "a", error);
1184                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["b"], "b", error);
1185                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["c"], "c[0]", error);
1186                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["d"], "d", error);
1187                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["e"], "e", error);
1188                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["f"], "f", error);
1189                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["g"], "g[0]", error);
1190                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["h"], "h", error);
1191                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["i"], "i", error);
1192                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["j.b"], "j.b", error);
1193                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["k.b[0].c"], "k.b[0].c", error);
1194                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[0].c"], "l[0].c", error);
1195                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[2].b[1].d[0]"], "l[2].b[1].d[0]", error);
1196                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[2].a.c"], "l[2].a.c", error);
1197
1198                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", glGetUniformLocation(program, "a"), error);
1199                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", glGetUniformLocation(program, "b"), error);
1200                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", glGetUniformLocation(program, "c"), error);
1201                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d", glGetUniformLocation(program, "d"), error);
1202                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "e", glGetUniformLocation(program, "e"), error);
1203                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "f", glGetUniformLocation(program, "f"), error);
1204                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "g", glGetUniformLocation(program, "g"), error);
1205                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "h", glGetUniformLocation(program, "h"), error);
1206                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "i", glGetUniformLocation(program, "i"), error);
1207                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "j.b", glGetUniformLocation(program, "j.b"), error);
1208                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "k.b[0].c", glGetUniformLocation(program, "k.b[0].c"),
1209                                                                                  error);
1210                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[0].c", glGetUniformLocation(program, "l[0].c"), error);
1211                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[2].b[1].d[0]",
1212                                                                                  glGetUniformLocation(program, "l[2].b[1].d[0]"), error);
1213                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[2].a.c", glGetUniformLocation(program, "l[2].a.c"),
1214                                                                                  error);
1215
1216                 GLenum props[] = { GL_NAME_LENGTH,
1217                                                    GL_TYPE,
1218                                                    GL_ARRAY_SIZE,
1219                                                    GL_OFFSET,
1220                                                    GL_BLOCK_INDEX,
1221                                                    GL_ARRAY_STRIDE,
1222                                                    GL_MATRIX_STRIDE,
1223                                                    GL_IS_ROW_MAJOR,
1224                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
1225                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
1226                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
1227                                                    GL_REFERENCED_BY_VERTEX_SHADER,
1228                                                    GL_LOCATION };
1229                 GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "a") };
1230                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["a"], 13, props, 13, expected, error);
1231                 GLint expected2[] = { 2, 35668, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "b") };
1232                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["b"], 13, props, 13, expected2, error);
1233                 GLint expected3[] = { 5, 36294, 3, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "c") };
1234                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["c"], 13, props, 13, expected3, error);
1235                 GLint expected4[] = { 2, 35676, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "d") };
1236                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["d"], 13, props, 13, expected4, error);
1237                 GLint expected5[] = { 2, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "e") };
1238                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["e"], 13, props, 13, expected5, error);
1239                 GLint expected6[] = { 2, 5124, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "f") };
1240                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["f"], 13, props, 13, expected6, error);
1241                 GLint expected7[] = { 5, 35674, 8, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "g") };
1242                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["g"], 13, props, 13, expected7, error);
1243                 GLint expected8[] = { 2, 5126, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "h") };
1244                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["h"], 13, props, 13, expected8, error);
1245                 GLint expected9[] = { 2, 35687, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "i") };
1246                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["i"], 13, props, 13, expected9, error);
1247                 GLint expected10[] = { 4, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "j.b") };
1248                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["j.b"], 13, props, 13, expected10, error);
1249                 GLint expected11[] = { 9, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "k.b[0].c") };
1250                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["k.b[0].c"], 13, props, 13, expected11, error);
1251                 GLint expected12[] = { 7, 36294, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[0].c") };
1252                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[0].c"], 13, props, 13, expected12, error);
1253                 GLint expected13[] = {
1254                         15, 5126, 2, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[2].b[1].d[0]")
1255                 };
1256                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[2].b[1].d[0]"], 13, props, 13, expected13, error);
1257                 GLint expected14[] = { 9, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[2].a.c") };
1258                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[2].a.c"], 13, props, 13, expected14, error);
1259
1260                 glDeleteProgram(program);
1261                 return error;
1262         }
1263 };
1264
1265 class UniformBlockTypes : public PIQBase
1266 {
1267         virtual std::string Title()
1268         {
1269                 return "Uniform Block Types Test";
1270         }
1271
1272         virtual std::string ShadersDesc()
1273         {
1274                 return "fallthrough fragment and vertex shaders with different types of uniform blocks used";
1275         }
1276
1277         virtual std::string PurposeExt()
1278         {
1279                 return "\n\n Purpose is to verify calls using GL_UNIFORM_BLOCK as an interface param.\n";
1280         }
1281
1282         virtual std::string VertexShader()
1283         {
1284                 return "#version 310 es                      \n"
1285                            "in vec4 position;                    \n"
1286                            ""
1287                            "uniform SimpleBlock {                \n"
1288                            "   mediump mat3x2 a;                         \n"
1289                            "   mediump mat4 b;                           \n"
1290                            "   vec4 c;                           \n"
1291                            "};                                   \n"
1292                            ""
1293                            "uniform NotSoSimpleBlockk {          \n"
1294                            "   ivec2 a[4];                       \n"
1295                            "   mediump mat3 b[2];                        \n"
1296                            "   mediump mat2 c;                           \n"
1297                            "} d;                                         \n"
1298                            ""
1299                            "void main(void)                                               \n"
1300                            "{                                                             \n"
1301                            "    mediump float tmp;                                        \n"
1302                            "    tmp =  a[0][1] * b[1][2] * c.x;                           \n"
1303                            "    tmp = tmp + float(d.a[2].y) + d.b[0][1][1] + d.c[1][1];   \n"
1304                            "    gl_Position = position * tmp;                             \n"
1305                            "}";
1306         }
1307
1308         virtual std::string FragmentShader()
1309         {
1310                 return "#version 310 es                \n"
1311                            "struct U {                     \n"
1312                            "   bool a[3];                  \n"
1313                            "   mediump vec4 b;                     \n"
1314                            "   mediump mat3 c;                     \n"
1315                            "   mediump float d[2];                 \n"
1316                            "};                             \n"
1317                            "struct UU {                    \n"
1318                            "   U a;                        \n"
1319                            "   U b[2];                     \n"
1320                            "   uvec2 c;                    \n"
1321                            "};                             \n"
1322                            ""
1323                            "uniform TrickyBlock {                            \n"
1324                            "   UU a[3];                                      \n"
1325                            "   mediump mat4 b;                               \n"
1326                            "   uint c;                                       \n"
1327                            "} e[2];                                          \n"
1328                            ""
1329                            "out mediump vec4 color;                        \n"
1330                            "void main() {                                  \n"
1331                            "    mediump float tmp;                         \n"
1332                            "    tmp = e[0].a[2].b[0].d[1] * float(e[1].c); \n"
1333                            "    color = vec4(0, 1, 0, 1) * tmp;            \n"
1334                            "}";
1335         }
1336
1337         virtual long Run()
1338         {
1339                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
1340                 glBindAttribLocation(program, 0, "position");
1341                 LinkProgram(program);
1342
1343                 long error = NO_ERROR;
1344
1345                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
1346                                                                         GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
1347                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES, 4, error);
1348                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NAME_LENGTH, 18, error);
1349
1350                 std::map<std::string, GLuint> indicesUB;
1351                 std::map<std::string, GLuint> indicesU;
1352                 VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "SimpleBlock", error);
1353                 VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "NotSoSimpleBlockk", error);
1354                 VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "TrickyBlock", error);
1355                 VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "TrickyBlock[1]", error);
1356                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
1357                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
1358                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);
1359                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.a[0]", error);
1360                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.c", error);
1361                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.b[0]", error);
1362                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "TrickyBlock.a[2].b[0].d", error);
1363
1364                 glUniformBlockBinding(program, indicesUB["SimpleBlock"], 0);
1365                 glUniformBlockBinding(program, indicesUB["NotSoSimpleBlockk"], 2);
1366                 glUniformBlockBinding(program, indicesUB["TrickyBlock"], 3);
1367                 glUniformBlockBinding(program, indicesUB["TrickyBlock[1]"], 4);
1368
1369                 VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], "SimpleBlock", error);
1370                 VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], "NotSoSimpleBlockk",
1371                                                                          error);
1372                 VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock"], "TrickyBlock[0]", error);
1373                 VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock[1]"], "TrickyBlock[1]", error);
1374                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
1375                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b", error);
1376                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);
1377                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.a[0]"], "NotSoSimpleBlockk.a[0]",
1378                                                                          error);
1379                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.c"], "NotSoSimpleBlockk.c",
1380                                                                          error);
1381                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.b[0]"], "NotSoSimpleBlockk.b[0]",
1382                                                                          error);
1383                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["TrickyBlock.a[2].b[0].d"],
1384                                                                          "TrickyBlock.a[2].b[0].d[0]", error);
1385
1386                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
1387                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
1388                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);
1389
1390                 GLenum props[] = {
1391                         GL_NAME_LENGTH,
1392                         GL_BUFFER_BINDING,
1393                         GL_REFERENCED_BY_COMPUTE_SHADER,
1394                         GL_REFERENCED_BY_FRAGMENT_SHADER,
1395                         GL_REFERENCED_BY_VERTEX_SHADER,
1396                         GL_BUFFER_DATA_SIZE,
1397                 };
1398                 GLint size;
1399                 glGetActiveUniformBlockiv(program, indicesUB["SimpleBlock"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
1400                 GLint expected[] = { 12, 0, 0, 0, 1, size };
1401                 VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], 6, props, 6, expected, error);
1402                 glGetActiveUniformBlockiv(program, indicesUB["NotSoSimpleBlockk"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
1403                 GLint expected2[] = { 18, 2, 0, 0, 1, size };
1404                 VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], 6, props, 6, expected2,
1405                                                                    error);
1406                 glGetActiveUniformBlockiv(program, indicesUB["TrickyBlock"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
1407                 GLint expected3[] = { 15, 3, 0, 1, 0, size };
1408                 VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock"], 6, props, 6, expected3, error);
1409                 GLint expected4[] = { 15, 4, 0, 1, 0, size };
1410                 VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock[1]"], 6, props, 6, expected4,
1411                                                                    error);
1412
1413                 GLenum props2[] = { GL_NAME_LENGTH,
1414                                                         GL_TYPE,
1415                                                         GL_ARRAY_SIZE,
1416                                                         GL_BLOCK_INDEX,
1417                                                         GL_ARRAY_STRIDE,
1418                                                         GL_IS_ROW_MAJOR,
1419                                                         GL_ATOMIC_COUNTER_BUFFER_INDEX,
1420                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
1421                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
1422                                                         GL_REFERENCED_BY_VERTEX_SHADER,
1423                                                         GL_LOCATION };
1424                 GLint expected5[] = { 2, 35687, 1, static_cast<GLint>(indicesUB["SimpleBlock"]), 0, 0, -1, 0, 0, 1, -1 };
1425                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 11, props2, 11, expected5, error);
1426                 GLenum props3[] = { GL_NAME_LENGTH,
1427                                                         GL_TYPE,
1428                                                         GL_ARRAY_SIZE,
1429                                                         GL_BLOCK_INDEX,
1430                                                         GL_MATRIX_STRIDE,
1431                                                         GL_IS_ROW_MAJOR,
1432                                                         GL_ATOMIC_COUNTER_BUFFER_INDEX,
1433                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
1434                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
1435                                                         GL_REFERENCED_BY_VERTEX_SHADER,
1436                                                         GL_LOCATION };
1437                 GLint expected6[] = { 27, 5126, 2, static_cast<GLint>(indicesUB["TrickyBlock"]), 0, 0, -1, 0, 1, 0, -1 };
1438                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["TrickyBlock.a[2].b[0].d"], 11, props3, 11, expected6,
1439                                                                    error);
1440
1441                 GLenum                   prop   = GL_ACTIVE_VARIABLES;
1442                 const GLsizei   bufSize = 1000;
1443                 GLsizei                  length;
1444                 GLint                    param[bufSize];
1445                 std::set<GLuint> exp;
1446                 exp.insert(indicesU["a"]);
1447                 exp.insert(indicesU["b"]);
1448                 exp.insert(indicesU["c"]);
1449                 glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], 1, &prop, bufSize, &length, param);
1450                 for (int i = 0; i < length; ++i)
1451                 {
1452                         if (exp.find(param[i]) == exp.end())
1453                         {
1454                                 m_context.getTestContext().getLog()
1455                                         << tcu::TestLog::Message
1456                                         << "Unexpected index found in active variables of SimpleBlock: " << param[i]
1457                                         << "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
1458                                         << tcu::TestLog::EndMessage;
1459                                 glDeleteProgram(program);
1460                                 return ERROR;
1461                         }
1462                         else if (length != 3)
1463                         {
1464                                 m_context.getTestContext().getLog()
1465                                         << tcu::TestLog::Message
1466                                         << "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
1467                                         << "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
1468                                 glDeleteProgram(program);
1469                                 return ERROR;
1470                         }
1471                 }
1472                 std::set<GLuint> exp2;
1473                 exp2.insert(indicesU["NotSoSimpleBlockk.a[0]"]);
1474                 exp2.insert(indicesU["NotSoSimpleBlockk.b[0]"]);
1475                 exp2.insert(indicesU["NotSoSimpleBlockk.c"]);
1476                 glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], 1, &prop, bufSize, &length,
1477                                                            param);
1478                 for (int i = 0; i < length; ++i)
1479                 {
1480                         if (exp2.find(param[i]) == exp2.end())
1481                         {
1482                                 m_context.getTestContext().getLog()
1483                                         << tcu::TestLog::Message
1484                                         << "Unexpected index found in active variables of NotSoSimpleBlockk: " << param[i]
1485                                         << "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
1486                                         << tcu::TestLog::EndMessage;
1487                                 glDeleteProgram(program);
1488                                 return ERROR;
1489                         }
1490                         else if (length != 3)
1491                         {
1492                                 m_context.getTestContext().getLog()
1493                                         << tcu::TestLog::Message
1494                                         << "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
1495                                         << "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
1496                                 glDeleteProgram(program);
1497                                 return ERROR;
1498                         }
1499                 }
1500
1501                 GLint res;
1502                 glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
1503                 if (res < 3)
1504                 {
1505                         m_context.getTestContext().getLog()
1506                                 << tcu::TestLog::Message << "Value of GL_MAX_NUM_ACTIVE_VARIABLES less than 3!"
1507                                 << tcu::TestLog::EndMessage;
1508                         glDeleteProgram(program);
1509                         return ERROR;
1510                 }
1511
1512                 glDeleteProgram(program);
1513                 return error;
1514         }
1515 };
1516
1517 class TransformFeedbackTypes : public SimpleShaders
1518 {
1519         virtual std::string Title()
1520         {
1521                 return "Transform Feedback Varying Types";
1522         }
1523
1524         virtual std::string ShadersDesc()
1525         {
1526                 return "fallthrough fragment and vertex shaders with different types of out variables used";
1527         }
1528
1529         virtual std::string PurposeExt()
1530         {
1531                 return "\n\n Purpose is to verify calls using GL_TRANSFORM_FEEDBACK_VARYING as an interface param.\n";
1532         }
1533
1534         virtual std::string VertexShader()
1535         {
1536                 return "#version 310 es                      \n"
1537                            "in vec4 position;                    \n"
1538                            ""
1539                            "flat out highp vec4 a;               \n"
1540                            "out mediump float b[2];              \n"
1541                            "flat out highp uvec2 c;              \n"
1542                            "flat out highp uint d;               \n"
1543                            "out mediump vec3 e[2];               \n"
1544                            "flat out int f;                      \n"
1545                            ""
1546                            "void main(void)                      \n"
1547                            "{                                    \n"
1548                            "   vec4 pos;                         \n"
1549                            "   a = vec4(1);                      \n"
1550                            "   b[0] = 1.1;                       \n"
1551                            "   b[1] = 1.1;                       \n"
1552                            "   c = uvec2(1u);                    \n"
1553                            "   d = 1u;                           \n"
1554                            "   e[0] = vec3(1.1);                 \n"
1555                            "   e[1] = vec3(1.1);                 \n"
1556                            "   f = 1;                            \n"
1557                            "   gl_Position = position;           \n"
1558                            "}";
1559         }
1560
1561         virtual long Run()
1562         {
1563                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
1564                 glBindAttribLocation(program, 0, "position");
1565                 const char* varyings[6] = { "a", "b[0]", "b[1]", "c", "d", "e" };
1566                 glTransformFeedbackVaryings(program, 6, varyings, GL_INTERLEAVED_ATTRIBS);
1567                 LinkProgram(program);
1568
1569                 long error = NO_ERROR;
1570
1571                 VerifyGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_ACTIVE_RESOURCES, 6, error);
1572                 VerifyGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_MAX_NAME_LENGTH, 5, error);
1573
1574                 std::map<std::string, GLuint> indices;
1575                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "a", error);
1576                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "b[0]", error);
1577                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "b[1]", error);
1578                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "c", error);
1579                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "d", error);
1580                 VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "e", error);
1581
1582                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["a"], "a", error);
1583                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[0]"], "b[0]", error);
1584                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[1]"], "b[1]", error);
1585                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["c"], "c", error);
1586                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["d"], "d", error);
1587                 VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["e"], "e", error);
1588
1589                 GLenum props[]  = { GL_NAME_LENGTH, GL_TYPE, GL_ARRAY_SIZE };
1590                 GLint  expected[] = { 2, 35666, 1 };
1591                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["a"], 3, props, 3, expected, error);
1592                 GLint expected2[] = { 5, 5126, 1 };
1593                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[0]"], 3, props, 3, expected2,
1594                                                                    error);
1595                 GLint expected3[] = { 5, 5126, 1 };
1596                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[1]"], 3, props, 3, expected3,
1597                                                                    error);
1598                 GLint expected4[] = { 2, 36294, 1 };
1599                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["c"], 3, props, 3, expected4, error);
1600                 GLint expected5[] = { 2, 5125, 1 };
1601                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["d"], 3, props, 3, expected5, error);
1602                 GLint expected6[] = { 2, 35665, 2 };
1603                 VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["e"], 3, props, 3, expected6, error);
1604
1605                 glDeleteProgram(program);
1606                 return error;
1607         }
1608 };
1609
1610 class AtomicCounterSimple : public ComputeShaderTest
1611 {
1612 public:
1613         virtual std::string Title()
1614         {
1615                 return "Atomic Counter Buffer Simple Test";
1616         }
1617
1618         virtual std::string ShadersDesc()
1619         {
1620                 return "compute shader with atomic counters used";
1621         }
1622
1623         virtual std::string PurposeExt()
1624         {
1625                 return "\n\n Purpose is to verify calls using GL_ATOMIC_COUNTER_BUFFER as an interface param.\n";
1626         }
1627
1628         virtual long Run()
1629         {
1630
1631                 GLint max_buffer_bindings = 0;
1632                 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &max_buffer_bindings);
1633                 if (max_buffer_bindings < 6)
1634                 {
1635                         OutputNotSupported("Test requires at least 6 atomic counter buffer binding points.");
1636                         return NOT_SUPPORTED;
1637                 }
1638
1639                 const char* const glsl_cs = "layout(local_size_x = 1, local_size_y = 1) in;  \n"
1640                                                                         "layout(std430) buffer Output {                  \n"
1641                                                                         "   mediump vec4 data;                           \n"
1642                                                                         "} g_out;                                        \n"
1643                                                                         ""
1644                                                                         "layout (binding = 1, offset = 0) uniform highp atomic_uint a;    \n"
1645                                                                         "layout (binding = 2, offset = 0) uniform highp atomic_uint b;    \n"
1646                                                                         "layout (binding = 2, offset = 4) uniform highp atomic_uint c;    \n"
1647                                                                         "layout (binding = 5, offset = 0) uniform highp atomic_uint d[3]; \n"
1648                                                                         "layout (binding = 5, offset = 12) uniform highp atomic_uint e;   \n"
1649                                                                         ""
1650                                                                         "void main() {                                                         \n"
1651                                                                         "   uint x = atomicCounterIncrement(d[0]) + atomicCounterIncrement(a); \n"
1652                                                                         "   uint y = atomicCounterIncrement(d[1]) + atomicCounterIncrement(b); \n"
1653                                                                         "   uint z = atomicCounterIncrement(d[2]) + atomicCounterIncrement(c); \n"
1654                                                                         "   uint w = atomicCounterIncrement(e);                                \n"
1655                                                                         "   g_out.data = vec4(float(x), float(y), float(z), float(w));         \n"
1656                                                                         "}";
1657
1658                 GLuint program = CreateComputeProgram(glsl_cs);
1659                 glLinkProgram(program);
1660                 if (!CheckProgram(program))
1661                 {
1662                         glDeleteProgram(program);
1663                         return ERROR;
1664                 }
1665                 glUseProgram(program);
1666
1667                 long error = NO_ERROR;
1668
1669                 VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, 3, error);
1670                 VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 2, error);
1671
1672                 std::map<std::string, GLuint> indicesU;
1673                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
1674                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
1675                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);
1676                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "d", error);
1677                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "e", error);
1678
1679                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
1680                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b", error);
1681                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);
1682                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["d"], "d[0]", error);
1683                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["e"], "e", error);
1684
1685                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
1686                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
1687                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);
1688                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d", -1, error);
1689                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "e", -1, error);
1690                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[0]", -1, error);
1691                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[1]", -1, error);
1692                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[2]", -1, error);
1693
1694                 GLenum            prop  = GL_ATOMIC_COUNTER_BUFFER_INDEX;
1695                 const GLsizei bufSize = 1000;
1696                 GLsizei           length;
1697                 GLint             res;
1698                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);
1699
1700                 GLenum props[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES, GL_ACTIVE_VARIABLES };
1701                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);
1702                 GLint expected[] = { 1, 4, 1, static_cast<GLint>(indicesU["a"]) };
1703                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 4, props, 4, expected, error);
1704
1705                 GLenum props2[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES };
1706                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
1707                 GLint expected2[] = { 2, 8, 2 };
1708                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected2, error);
1709                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["c"], 1, &prop, bufSize, &length, &res);
1710                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected2, error);
1711
1712                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["d"], 1, &prop, bufSize, &length, &res);
1713                 GLint expected3[] = { 5, 16, 2 };
1714                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected3, error);
1715                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["e"], 1, &prop, bufSize, &length, &res);
1716                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected3, error);
1717
1718                 GLenum                   prop2 = GL_ACTIVE_VARIABLES;
1719                 GLint                    param[bufSize];
1720                 std::set<GLuint> exp;
1721                 exp.insert(indicesU["b"]);
1722                 exp.insert(indicesU["c"]);
1723                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
1724                 glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param);
1725                 for (int i = 0; i < length; ++i)
1726                 {
1727                         if (exp.find(param[i]) == exp.end() || length != 2)
1728                         {
1729                                 m_context.getTestContext().getLog()
1730                                         << tcu::TestLog::Message << "Length: " << length
1731                                         << "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param[i]
1732                                         << tcu::TestLog::EndMessage;
1733                                 glDeleteProgram(program);
1734                                 return ERROR;
1735                         }
1736                 }
1737                 std::set<GLuint> exp2;
1738                 GLint                    param2[bufSize];
1739                 exp2.insert(indicesU["d"]);
1740                 exp2.insert(indicesU["e"]);
1741                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["d"], 1, &prop, bufSize, &length, &res);
1742                 glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param2);
1743                 for (int i = 0; i < length; ++i)
1744                 {
1745                         if (exp2.find(param2[i]) == exp2.end() || length != 2)
1746                         {
1747                                 m_context.getTestContext().getLog()
1748                                         << tcu::TestLog::Message << "Length: " << length
1749                                         << "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param2[i]
1750                                         << tcu::TestLog::EndMessage;
1751                                 glDeleteProgram(program);
1752                                 return ERROR;
1753                         }
1754                 }
1755
1756                 glDeleteProgram(program);
1757                 return error;
1758         }
1759 };
1760
1761 class AtomicCounterSimpleOneBuffer : public ComputeShaderTest
1762 {
1763 public:
1764         virtual std::string Title()
1765         {
1766                 return "Atomic Counter Buffer Simple One Buffer Test";
1767         }
1768
1769         virtual std::string ShadersDesc()
1770         {
1771                 return "compute shader with atomic counters used";
1772         }
1773
1774         virtual std::string PurposeExt()
1775         {
1776                 return "\n\n Purpose is to verify calls using GL_ATOMIC_COUNTER_BUFFER as an interface param.\n";
1777         }
1778
1779         virtual long Run()
1780         {
1781
1782                 GLint max_buffer_bindings = 0;
1783                 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &max_buffer_bindings);
1784                 if (max_buffer_bindings < 3)
1785                 {
1786                         OutputNotSupported("Test requires at least 3 atomic counter buffer binding points.");
1787                         return NOT_SUPPORTED;
1788                 }
1789
1790                 const char* const glsl_cs = "layout(local_size_x = 1, local_size_y = 1) in;  \n"
1791                                                                         "layout(std430) buffer Output {                  \n"
1792                                                                         "   mediump vec4 data;                           \n"
1793                                                                         "} g_out;                                        \n"
1794                                                                         ""
1795                                                                         "layout (binding = 0, offset = 0) uniform highp atomic_uint a;    \n"
1796                                                                         "layout (binding = 0, offset = 4) uniform highp atomic_uint b[3]; \n"
1797                                                                         "layout (binding = 0, offset = 16) uniform highp atomic_uint c;   \n"
1798                                                                         ""
1799                                                                         "void main() {                                                         \n"
1800                                                                         "   uint x = atomicCounterIncrement(b[0]) + atomicCounterIncrement(a); \n"
1801                                                                         "   uint y = atomicCounterIncrement(b[1]) + atomicCounterIncrement(a); \n"
1802                                                                         "   uint z = atomicCounterIncrement(b[2]) + atomicCounterIncrement(a); \n"
1803                                                                         "   uint w = atomicCounterIncrement(c);                                \n"
1804                                                                         "   g_out.data = vec4(float(x), float(y), float(z), float(w));         \n"
1805                                                                         "}";
1806
1807                 GLuint program = CreateComputeProgram(glsl_cs);
1808                 glLinkProgram(program);
1809                 if (!CheckProgram(program))
1810                 {
1811                         glDeleteProgram(program);
1812                         return ERROR;
1813                 }
1814                 glUseProgram(program);
1815
1816                 long error = NO_ERROR;
1817
1818                 VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, 1, error);
1819                 VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 3, error);
1820
1821                 std::map<std::string, GLuint> indicesU;
1822                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
1823                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
1824                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);
1825
1826                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
1827                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b[0]", error);
1828                 VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);
1829
1830                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
1831                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
1832                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);
1833                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[0]", -1, error);
1834                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[1]", -1, error);
1835                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[2]", -1, error);
1836
1837                 GLenum            prop  = GL_ATOMIC_COUNTER_BUFFER_INDEX;
1838                 const GLsizei bufSize = 1000;
1839                 GLsizei           length;
1840                 GLint             res;
1841
1842                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);
1843                 if (res != 0)
1844                 {
1845                         m_context.getTestContext().getLog()
1846                                 << tcu::TestLog::Message << "Got buffer index " << res << ", expected 0." << tcu::TestLog::EndMessage;
1847                         glDeleteProgram(program);
1848                         return ERROR;
1849                 }
1850
1851                 GLenum props[]  = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES };
1852                 GLint  expected[] = { 0, 20, 3 };
1853                 VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props, 3, expected, error);
1854
1855                 GLenum                   prop2 = GL_ACTIVE_VARIABLES;
1856                 GLint                    param[bufSize];
1857                 std::set<GLuint> exp;
1858                 exp.insert(indicesU["a"]);
1859                 exp.insert(indicesU["b"]);
1860                 exp.insert(indicesU["c"]);
1861
1862                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
1863                 if (res != 0)
1864                 {
1865                         m_context.getTestContext().getLog()
1866                                 << tcu::TestLog::Message << "Got buffer index " << res << ", expected 0." << tcu::TestLog::EndMessage;
1867                         glDeleteProgram(program);
1868                         return ERROR;
1869                 }
1870
1871                 glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param);
1872                 for (int i = 0; i < length; ++i)
1873                 {
1874                         if (exp.find(param[i]) == exp.end() || length != 3)
1875                         {
1876                                 m_context.getTestContext().getLog()
1877                                         << tcu::TestLog::Message << "Length: " << length
1878                                         << "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param[i]
1879                                         << tcu::TestLog::EndMessage;
1880                                 glDeleteProgram(program);
1881                                 return ERROR;
1882                         }
1883                 }
1884
1885                 glDeleteProgram(program);
1886                 return error;
1887         }
1888 };
1889
1890 class InvalidValueTest : public SimpleShaders
1891 {
1892         virtual std::string Title()
1893         {
1894                 return "Invalid Value Test";
1895         }
1896
1897         virtual std::string PassCriteria()
1898         {
1899                 return "GL_INVALID_VALUE error is generated after every function call.";
1900         }
1901
1902         virtual std::string Purpose()
1903         {
1904                 return "Verify that wrong use of functions generates GL_INVALID_VALUE as described in spec.";
1905         }
1906
1907         virtual std::string Method()
1908         {
1909                 return "Call functions with invalid values and check if GL_INVALID_VALUE was generated.";
1910         }
1911
1912         virtual long Run()
1913         {
1914                 long error = NO_ERROR;
1915
1916                 GLint   res;
1917                 GLsizei len               = 0;
1918                 GLchar  name[100] = { '\0' };
1919                 GLenum  props[1]  = { GL_NAME_LENGTH };
1920
1921                 m_context.getTestContext().getLog()
1922                         << tcu::TestLog::Message << "Case 1: <program> not a name of shader/program object"
1923                         << tcu::TestLog::EndMessage;
1924                 glGetProgramInterfaceiv(1337u, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
1925                 ExpectError(GL_INVALID_VALUE, error);
1926                 glGetProgramResourceIndex(31337u, GL_PROGRAM_INPUT, "pie");
1927                 ExpectError(GL_INVALID_VALUE, error);
1928                 glGetProgramResourceName(1337u, GL_PROGRAM_INPUT, 0, 1024, &len, name);
1929                 ExpectError(GL_INVALID_VALUE, error);
1930                 glGetProgramResourceiv(1337u, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
1931                 ExpectError(GL_INVALID_VALUE, error);
1932                 glGetProgramResourceLocation(1337u, GL_PROGRAM_INPUT, "pie");
1933                 ExpectError(GL_INVALID_VALUE, error);
1934                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1: finished" << tcu::TestLog::EndMessage;
1935
1936                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
1937                 glBindAttribLocation(program, 0, "position");
1938                 LinkProgram(program);
1939
1940                 m_context.getTestContext().getLog()
1941                         << tcu::TestLog::Message
1942                         << "Case 2: <index> is greater than the number of the active resources in GetProgramResourceName"
1943                         << tcu::TestLog::EndMessage;
1944                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1: finished" << tcu::TestLog::EndMessage;
1945                 glGetProgramResourceName(program, GL_PROGRAM_INPUT, 3000, 1024, &len, name);
1946                 ExpectError(GL_INVALID_VALUE, error);
1947                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2: finished" << tcu::TestLog::EndMessage;
1948
1949                 m_context.getTestContext().getLog()
1950                         << tcu::TestLog::Message << "Case 3: <propCount> is zero in GetProgramResourceiv"
1951                         << tcu::TestLog::EndMessage;
1952                 glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 0, props, 1024, &len, &res);
1953                 ExpectError(GL_INVALID_VALUE, error);
1954                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 3: finished" << tcu::TestLog::EndMessage;
1955
1956                 std::string str = "position";
1957                 glGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, -100, NULL, const_cast<char*>(str.c_str()));
1958                 ExpectError(GL_INVALID_VALUE, error);
1959                 GLenum prop = GL_NAME_LENGTH;
1960                 glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, &prop, -100, &len, &res);
1961                 ExpectError(GL_INVALID_VALUE, error);
1962
1963                 glDeleteProgram(program);
1964                 return error;
1965         }
1966 };
1967
1968 class InvalidEnumTest : public SimpleShaders
1969 {
1970         virtual std::string Title()
1971         {
1972                 return "Invalid Enum Test";
1973         }
1974
1975         virtual std::string PassCriteria()
1976         {
1977                 return "GL_INVALID_ENUM error is generated after every function call.";
1978         }
1979
1980         virtual std::string Purpose()
1981         {
1982                 return "Verify that wrong use of functions generates GL_INVALID_ENUM as described in spec.";
1983         }
1984
1985         virtual std::string Method()
1986         {
1987                 return "Call functions with invalid enums and check if GL_INVALID_ENUM was generated.";
1988         }
1989
1990         // make sure at least one atomic counter resource is active
1991         virtual std::string FragmentShader()
1992         {
1993                 return "#version 310 es                                        \n"
1994                            "layout (binding = 0, offset = 0) uniform highp atomic_uint a;\n"
1995                            "out mediump vec4 outColor;                             \n"
1996                            "void main(void) {                                      \n"
1997                            "   uint b = atomicCounterIncrement(a);                 \n"
1998                            "   outColor = vec4(float(b));                          \n"
1999                            "}                                                      \n";
2000         }
2001
2002         virtual long Run()
2003         {
2004                 GLint max_buffers = 0, max_counters = 0;
2005                 glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &max_buffers);
2006                 glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTERS, &max_counters);
2007                 if (max_buffers < 1 || max_counters < 1)
2008                 {
2009                         OutputNotSupported("Test requires at least 1 atomic counter.");
2010                         return NOT_SUPPORTED;
2011                 }
2012
2013                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2014                 glBindAttribLocation(program, 0, "position");
2015                 LinkProgram(program);
2016
2017                 long error = NO_ERROR;
2018
2019                 GLint   res;
2020                 GLsizei len               = 0;
2021                 GLchar  name[100] = { '\0' };
2022                 GLenum  props[1]  = { GL_TEXTURE_1D };
2023
2024                 m_context.getTestContext().getLog()
2025                         << tcu::TestLog::Message << "Case 1: <programInterface> is ATOMIC_COUNTER_BUFFER in "
2026                                                                                 "GetProgramResourceIndex or GetProgramResourceName"
2027                         << tcu::TestLog::EndMessage;
2028                 glGetProgramResourceIndex(program, GL_ATOMIC_COUNTER_BUFFER, name);
2029                 ExpectError(GL_INVALID_ENUM, error);
2030                 glGetProgramResourceName(program, GL_ATOMIC_COUNTER_BUFFER, 0, 1024, &len, name);
2031                 ExpectError(GL_INVALID_ENUM, error);
2032                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1 finished" << tcu::TestLog::EndMessage;
2033
2034                 m_context.getTestContext().getLog()
2035                         << tcu::TestLog::Message
2036                         << "Case 2: <props> is not a property name supported by the command GetProgramResourceiv"
2037                         << tcu::TestLog::EndMessage;
2038                 glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
2039                 ExpectError(GL_INVALID_ENUM, error);
2040                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2 finished" << tcu::TestLog::EndMessage;
2041
2042                 glGetProgramResourceLocation(program, GL_ATOMIC_COUNTER_BUFFER, "position");
2043                 ExpectError(GL_INVALID_ENUM, error);
2044
2045                 glDeleteProgram(program);
2046                 return error;
2047         }
2048 };
2049
2050 class InvalidOperationTest : public SimpleShaders
2051 {
2052         virtual std::string Title()
2053         {
2054                 return "Invalid Operation Test";
2055         }
2056
2057         virtual std::string PassCriteria()
2058         {
2059                 return "GL_INVALID_OPERATION error is generated after every function call.";
2060         }
2061
2062         virtual std::string Purpose()
2063         {
2064                 return "Verify that wrong use of functions generates GL_INVALID_OPERATION as described in spec.";
2065         }
2066
2067         virtual std::string Method()
2068         {
2069                 return "Perform invalid operation and check if GL_INVALID_OPERATION was generated.";
2070         }
2071
2072         virtual long Run()
2073         {
2074                 long error = NO_ERROR;
2075
2076                 GLuint program  = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2077                 GLuint program2 = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2078                 glBindAttribLocation(program, 0, "position");
2079                 LinkProgram(program);
2080
2081                 const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
2082                 GLint            res;
2083                 GLsizei          len       = 0;
2084                 GLchar           name[100] = { '\0' };
2085                 GLenum           props[1]  = { GL_OFFSET };
2086
2087                 m_context.getTestContext().getLog()
2088                         << tcu::TestLog::Message << "Case 1: <program> is the name of a shader object" << tcu::TestLog::EndMessage;
2089                 glGetProgramInterfaceiv(sh, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
2090                 ExpectError(GL_INVALID_OPERATION, error);
2091                 glGetProgramResourceIndex(sh, GL_PROGRAM_INPUT, "pie");
2092                 ExpectError(GL_INVALID_OPERATION, error);
2093                 glGetProgramResourceName(sh, GL_PROGRAM_INPUT, 0, 1024, &len, name);
2094                 ExpectError(GL_INVALID_OPERATION, error);
2095                 glGetProgramResourceiv(sh, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
2096                 ExpectError(GL_INVALID_OPERATION, error);
2097                 glGetProgramResourceLocation(sh, GL_PROGRAM_INPUT, "pie");
2098                 ExpectError(GL_INVALID_OPERATION, error);
2099                 glDeleteShader(sh);
2100                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1 finished" << tcu::TestLog::EndMessage;
2101
2102                 m_context.getTestContext().getLog()
2103                         << tcu::TestLog::Message << "Case 2: <pname> is not supported in GetProgramInterfaceiv"
2104                         << tcu::TestLog::EndMessage;
2105                 glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
2106                 ExpectError(GL_INVALID_OPERATION, error);
2107                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2 finished" << tcu::TestLog::EndMessage;
2108
2109                 m_context.getTestContext().getLog()
2110                         << tcu::TestLog::Message << "Case 3: <props> is not supported in GetProgramResourceiv"
2111                         << tcu::TestLog::EndMessage;
2112                 glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
2113                 ExpectError(GL_INVALID_OPERATION, error);
2114                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 3 finished" << tcu::TestLog::EndMessage;
2115
2116                 m_context.getTestContext().getLog()
2117                         << tcu::TestLog::Message << "Case 4: <program> has not been linked in GetProgramResourceLocation"
2118                         << tcu::TestLog::EndMessage;
2119                 glGetProgramResourceLocation(program2, GL_PROGRAM_INPUT, "pie");
2120                 ExpectError(GL_INVALID_OPERATION, error);
2121                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 4 finished" << tcu::TestLog::EndMessage;
2122
2123                 glDeleteProgram(program);
2124                 glDeleteProgram(program2);
2125                 return error;
2126         }
2127 };
2128
2129 class ShaderStorageBlock : public ComputeShaderTest
2130 {
2131         virtual std::string Title()
2132         {
2133                 return "Shader Storage Block Test";
2134         }
2135
2136         virtual std::string ShadersDesc()
2137         {
2138                 return "compute shader different types of storage blocks used";
2139         }
2140
2141         virtual std::string PurposeExt()
2142         {
2143                 return "\n\n Purpose is to verify calls using GL_BUFFER_VARIABLE and GL_SHADER_STORAGE_BLOCK as an interface "
2144                            "params.\n";
2145         }
2146
2147         virtual std::string ComputeShader()
2148         {
2149                 return "layout(local_size_x = 1, local_size_y = 1) in;  \n"
2150                            "layout(std430) buffer Output {                  \n"
2151                            "   mediump vec4 data;                           \n"
2152                            "} g_out;                                        \n"
2153                            ""
2154                            "struct U {                     \n"
2155                            "   bool a[3];                  \n"
2156                            "   mediump vec4 b;                     \n"
2157                            "   mediump mat3 c;                     \n"
2158                            "   mediump float d[2];                 \n"
2159                            "};                             \n"
2160                            "struct UU {                    \n"
2161                            "   U a;                        \n"
2162                            "   U b[2];                     \n"
2163                            "   uvec2 c;                    \n"
2164                            "};                             \n"
2165                            ""
2166                            "layout(binding=4) buffer TrickyBuffer {          \n"
2167                            "   UU a[3];                                      \n"
2168                            "   mediump mat4 b;                               \n"
2169                            "   uint c;                                       \n"
2170                            "} e[2];                                          \n"
2171                            ""
2172                            "layout(binding = 0) buffer SimpleBuffer {                \n"
2173                            "   mediump mat3x2 a;                                     \n"
2174                            "   mediump mat4 b;                                       \n"
2175                            "   mediump vec4 c;                                       \n"
2176                            "};                                                       \n"
2177                            ""
2178                            "layout(binding = 1) buffer NotSoSimpleBuffer {           \n"
2179                            "   ivec2 a[4];                                           \n"
2180                            "   mediump mat3 b[2];                                    \n"
2181                            "   mediump mat2 c;                                       \n"
2182                            "} d;                                                     \n"
2183                            ""
2184                            "void main() {                                    \n"
2185                            "    mediump float tmp;                           \n"
2186                            "    mediump float tmp2;                          \n"
2187                            "    tmp = e[0].a[0].b[0].d[0] * float(e[1].c);   \n"
2188                            "    tmp2 = a[0][0] * b[0][0] * c.x;                                \n"
2189                            "    tmp2 = tmp2 + float(d.a[0].y) + d.b[0][0][0] + d.c[0][0];      \n"
2190                            "    g_out.data = vec4(0, 1, 0, 1) * tmp * tmp2;                    \n"
2191                            "}";
2192         }
2193
2194         virtual long Run()
2195         {
2196                 GLuint program = CreateComputeProgram(ComputeShader());
2197                 glLinkProgram(program);
2198                 if (!CheckProgram(program))
2199                 {
2200                         glDeleteProgram(program);
2201                         return ERROR;
2202                 }
2203                 glUseProgram(program);
2204
2205                 long error = NO_ERROR;
2206
2207                 GLint res;
2208                 VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 28, error);
2209                 glGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_ACTIVE_RESOURCES, &res);
2210                 if (res < 7)
2211                 {
2212                         m_context.getTestContext().getLog()
2213                                 << tcu::TestLog::Message
2214                                 << "Error on: glGetProgramInterfaceiv, if: GL_BUFFER_VARIABLE, param: GL_ACTIVE_RESOURCES\n"
2215                                 << "Expected value greater or equal to 7, got " << res << tcu::TestLog::EndMessage;
2216                         glDeleteProgram(program);
2217                         return ERROR;
2218                 }
2219                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 5, error);
2220                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 18, error);
2221
2222                 std::map<std::string, GLuint> indicesSSB;
2223                 std::map<std::string, GLuint> indicesBV;
2224                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "SimpleBuffer", error);
2225                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "NotSoSimpleBuffer", error);
2226                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "TrickyBuffer", error);
2227                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "TrickyBuffer[1]", error);
2228                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "a", error);
2229                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "b", error);
2230                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "c", error);
2231                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.a[0]", error);
2232                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.c", error);
2233                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.b[0]", error);
2234                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.a[0].b[0].d", error);
2235                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.b", error);
2236                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.c", error);
2237
2238                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], "SimpleBuffer",
2239                                                                          error);
2240                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"],
2241                                                                          "NotSoSimpleBuffer", error);
2242                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer"], "TrickyBuffer[0]",
2243                                                                          error);
2244                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer[1]"], "TrickyBuffer[1]",
2245                                                                          error);
2246                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["a"], "a", error);
2247                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["b"], "b", error);
2248                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["c"], "c", error);
2249                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.a[0]"],
2250                                                                          "NotSoSimpleBuffer.a[0]", error);
2251                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.c"],
2252                                                                          "NotSoSimpleBuffer.c", error);
2253                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.b[0]"],
2254                                                                          "NotSoSimpleBuffer.b[0]", error);
2255                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.a[0].b[0].d"],
2256                                                                          "TrickyBuffer.a[0].b[0].d[0]", error);
2257                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.b"], "TrickyBuffer.b", error);
2258                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.c"], "TrickyBuffer.c", error);
2259
2260                 GLenum props[] = { GL_NAME_LENGTH,
2261                                                    GL_BUFFER_BINDING,
2262                                                    GL_NUM_ACTIVE_VARIABLES,
2263                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
2264                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
2265                                                    GL_REFERENCED_BY_VERTEX_SHADER };
2266                 GLint expected[] = { 13, 0, 3, 1, 0, 0 };
2267                 VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], 6, props, 6, expected,
2268                                                                    error);
2269                 GLenum props2[] = { GL_NAME_LENGTH, GL_BUFFER_BINDING, GL_REFERENCED_BY_COMPUTE_SHADER,
2270                                                         GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_VERTEX_SHADER };
2271                 GLint expected2[] = { 18, 1, 1, 0, 0 };
2272                 VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"], 5, props2, 5,
2273                                                                    expected2, error);
2274                 GLint expected3[] = { 16, 4, 1, 0, 0 };
2275                 VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer"], 5, props2, 5,
2276                                                                    expected3, error);
2277                 GLint expected4[] = { 16, 5, 1, 0, 0 };
2278                 VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer[1]"], 5, props2, 5,
2279                                                                    expected4, error);
2280
2281                 GLenum props3[] = { GL_NAME_LENGTH,
2282                                                         GL_TYPE,
2283                                                         GL_ARRAY_SIZE,
2284                                                         GL_BLOCK_INDEX,
2285                                                         GL_ARRAY_STRIDE,
2286                                                         GL_IS_ROW_MAJOR,
2287                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2288                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2289                                                         GL_REFERENCED_BY_VERTEX_SHADER,
2290                                                         GL_TOP_LEVEL_ARRAY_SIZE,
2291                                                         GL_TOP_LEVEL_ARRAY_STRIDE };
2292                 GLint expected5[] = { 2, 35687, 1, static_cast<GLint>(indicesSSB["SimpleBuffer"]), 0, 0, 1, 0, 0, 1, 0 };
2293                 VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a"], 11, props3, 11, expected5, error);
2294                 GLenum props4[] = { GL_NAME_LENGTH,
2295                                                         GL_TYPE,
2296                                                         GL_ARRAY_SIZE,
2297                                                         GL_BLOCK_INDEX,
2298                                                         GL_MATRIX_STRIDE,
2299                                                         GL_IS_ROW_MAJOR,
2300                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2301                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2302                                                         GL_REFERENCED_BY_VERTEX_SHADER,
2303                                                         GL_TOP_LEVEL_ARRAY_SIZE };
2304                 GLint expected6[] = { 28, 5126, 2, static_cast<GLint>(indicesSSB["TrickyBuffer"]), 0, 0, 1, 0, 0, 3 };
2305                 VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.a[0].b[0].d"], 10, props4, 10,
2306                                                                    expected6, error);
2307
2308                 GLenum                   prop   = GL_ACTIVE_VARIABLES;
2309                 const GLsizei   bufSize = 1000;
2310                 GLsizei                  length;
2311                 GLint                    param[bufSize];
2312                 std::set<GLuint> exp;
2313                 exp.insert(indicesBV["a"]);
2314                 exp.insert(indicesBV["b"]);
2315                 exp.insert(indicesBV["c"]);
2316                 glGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], 1, &prop, bufSize, &length,
2317                                                            param);
2318                 for (int i = 0; i < length; ++i)
2319                 {
2320                         if (exp.find(param[i]) == exp.end())
2321                         {
2322                                 m_context.getTestContext().getLog()
2323                                         << tcu::TestLog::Message
2324                                         << "Unexpected index found in active variables of SimpleBuffer: " << param[i]
2325                                         << "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: "
2326                                            "GL_SHADER_STORAGE_BLOCK"
2327                                         << tcu::TestLog::EndMessage;
2328                                 glDeleteProgram(program);
2329                                 return ERROR;
2330                         }
2331                         else if (length != 3)
2332                         {
2333                                 m_context.getTestContext().getLog()
2334                                         << tcu::TestLog::Message
2335                                         << "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_SHADER_STORAGE_BLOCK"
2336                                         << "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
2337                                 glDeleteProgram(program);
2338                                 return ERROR;
2339                         }
2340                 }
2341                 std::set<GLuint> exp2;
2342                 exp2.insert(indicesBV["NotSoSimpleBuffer.a[0]"]);
2343                 exp2.insert(indicesBV["NotSoSimpleBuffer.b[0]"]);
2344                 exp2.insert(indicesBV["NotSoSimpleBuffer.c"]);
2345                 glGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"], 1, &prop, bufSize,
2346                                                            &length, param);
2347                 for (int i = 0; i < length; ++i)
2348                 {
2349                         if (exp2.find(param[i]) == exp2.end())
2350                         {
2351                                 m_context.getTestContext().getLog()
2352                                         << tcu::TestLog::Message
2353                                         << "Unexpected index found in active variables of NotSoSimpleBuffer: " << param[i]
2354                                         << "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: "
2355                                            "GL_SHADER_STORAGE_BLOCK"
2356                                         << tcu::TestLog::EndMessage;
2357                                 glDeleteProgram(program);
2358                                 return ERROR;
2359                         }
2360                         else if (length != 3)
2361                         {
2362                                 m_context.getTestContext().getLog()
2363                                         << tcu::TestLog::Message
2364                                         << "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_SHADER_STORAGE_BLOCK"
2365                                         << param[i] << "\nExpected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
2366                                 glDeleteProgram(program);
2367                                 return ERROR;
2368                         }
2369                 }
2370
2371                 glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
2372                 if (res < 3)
2373                 {
2374                         m_context.getTestContext().getLog()
2375                                 << tcu::TestLog::Message << "Value of GL_MAX_NUM_ACTIVE_VARIABLES less than 3!\n"
2376                                 << "Call: glGetProgramInterfaceiv, interface: GL_SHADER_STORAGE_BLOCK" << tcu::TestLog::EndMessage;
2377                         return ERROR;
2378                 }
2379
2380                 glDeleteProgram(program);
2381                 return error;
2382         }
2383 };
2384
2385 class NullLength : public SimpleShaders
2386 {
2387
2388         virtual std::string Title()
2389         {
2390                 return "NULL Length Test";
2391         }
2392
2393         virtual std::string PurposeExt()
2394         {
2395                 return "\n\n Purpose is to verify that GetProgramResourceName with null length doesn't return length (doesn't "
2396                            "crash).\n";
2397         }
2398
2399         virtual std::string VertexShader()
2400         {
2401                 return "#version 310 es                      \n"
2402                            "in vec4 position;                    \n"
2403                            "void main(void)                      \n"
2404                            "{                                    \n"
2405                            "    gl_Position = position;          \n"
2406                            "}";
2407         }
2408
2409         virtual std::string FragmentShader()
2410         {
2411                 return "#version 310 es                \n"
2412                            "out mediump vec4 color;                \n"
2413                            "void main() {                  \n"
2414                            "    color = vec4(0, 1, 0, 1);  \n"
2415                            "}";
2416         }
2417
2418         virtual long Run()
2419         {
2420                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2421                 glBindAttribLocation(program, 0, "position");
2422                 LinkProgram(program);
2423
2424                 GLchar name[1024] = { '\0' };
2425                 GLuint index      = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color");
2426                 GLenum prop               = GL_ARRAY_SIZE;
2427                 GLint  res;
2428                 glGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, 1024, NULL, name);
2429                 glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, 1, &prop, 1, NULL, &res);
2430
2431                 std::string expected = "color";
2432                 if (name != expected)
2433                 {
2434                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Expected name: " << expected
2435                                                                                                 << ", got: " << name << tcu::TestLog::EndMessage;
2436                         glDeleteProgram(program);
2437                         return ERROR;
2438                 }
2439                 else if (res != 1)
2440                 {
2441                         m_context.getTestContext().getLog()
2442                                 << tcu::TestLog::Message << "Expected array_size: 1, got: " << res << tcu::TestLog::EndMessage;
2443                         glDeleteProgram(program);
2444                         return ERROR;
2445                 }
2446
2447                 glDeleteProgram(program);
2448                 return NO_ERROR;
2449         }
2450 };
2451
2452 class ArraysOfArrays : public SimpleShaders
2453 {
2454
2455         virtual std::string Title()
2456         {
2457                 return "Arrays Of Arrays Test";
2458         }
2459
2460         virtual std::string ShadersDesc()
2461         {
2462                 return "fallthrough fragment and vertex shaders with multi dimensional uniform array used";
2463         }
2464
2465         virtual std::string PurposeExt()
2466         {
2467                 return "\n\n Purpose is to verify that feature works correctly with arrays_of_arrays feature.\n";
2468         }
2469
2470         virtual std::string VertexShader()
2471         {
2472                 return "#version 310 es                      \n"
2473                            "in vec4 position;                    \n"
2474                            "uniform mediump vec4 a[3][4][5];             \n"
2475                            "void main(void)                      \n"
2476                            "{                                                 \n"
2477                            "    gl_Position = position + a[2][1][0];          \n"
2478                            "}";
2479         }
2480
2481         virtual std::string FragmentShader()
2482         {
2483                 return "#version 310 es                \n"
2484                            "out mediump vec4 color;                \n"
2485                            "void main() {                  \n"
2486                            "    color = vec4(0, 1, 0, 1);  \n"
2487                            "}";
2488         }
2489
2490         virtual long Run()
2491         {
2492                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2493                 glBindAttribLocation(program, 0, "position");
2494                 LinkProgram(program);
2495
2496                 long error = NO_ERROR;
2497
2498                 VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 11, error);
2499
2500                 std::map<std::string, GLuint> indices;
2501                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "a[2][1]", error);
2502                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, "a[2][1][0]", indices["a[2][1]"], error);
2503
2504                 VerifyGetProgramResourceName(program, GL_UNIFORM, indices["a[2][1]"], "a[2][1][0]", error);
2505
2506                 GLenum props[] = { GL_NAME_LENGTH,
2507                                                    GL_TYPE,
2508                                                    GL_ARRAY_SIZE,
2509                                                    GL_OFFSET,
2510                                                    GL_BLOCK_INDEX,
2511                                                    GL_ARRAY_STRIDE,
2512                                                    GL_MATRIX_STRIDE,
2513                                                    GL_IS_ROW_MAJOR,
2514                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
2515                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
2516                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
2517                                                    GL_REFERENCED_BY_VERTEX_SHADER,
2518                                                    GL_LOCATION };
2519                 GLint expected[] = { 11, 35666, 5, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "a[2][1]") };
2520                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["a[2][1]"], 13, props, 13, expected, error);
2521
2522                 glDeleteProgram(program);
2523                 return error;
2524         }
2525 };
2526
2527 class TopLevelArray : public ComputeShaderTest
2528 {
2529
2530         virtual std::string Title()
2531         {
2532                 return "Top Level Array Test";
2533         }
2534
2535         virtual std::string ShadersDesc()
2536         {
2537                 return "compute shader with multi dimensional array used inside storage block";
2538         }
2539
2540         virtual std::string PurposeExt()
2541         {
2542                 return "\n\n Purpose is to verify that feature works correctly when querying for GL_TOP_LEVEL_ARRAY_SIZE\n"
2543                            " and GL_TOP_LEVEL_ARRAY_STRIDE.\n";
2544         }
2545
2546         virtual std::string ComputeShader()
2547         {
2548                 return "layout(local_size_x = 1, local_size_y = 1) in; \n"
2549                            "layout(std430) buffer Outp {                   \n"
2550                            "   mediump vec4 d;                             \n"
2551                            "} g_out;                                       \n"
2552                            ""
2553                            "buffer Block {                       \n"
2554                            "   mediump vec4 a[5][4][3];          \n"
2555                            "};                                   \n"
2556                            ""
2557                            "void main(void)                      \n"
2558                            "{                                    \n"
2559                            "    g_out.d = a[0][0][0];            \n"
2560                            "}";
2561         }
2562
2563         virtual long Run()
2564         {
2565                 GLuint program = CreateComputeProgram(ComputeShader());
2566                 glLinkProgram(program);
2567                 if (!CheckProgram(program))
2568                 {
2569                         glDeleteProgram(program);
2570                         return ERROR;
2571                 }
2572                 glUseProgram(program);
2573
2574                 long error = NO_ERROR;
2575
2576                 VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 11, error);
2577                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 6, error);
2578                 VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 2, error);
2579
2580                 std::map<std::string, GLuint> indicesSSB;
2581                 std::map<std::string, GLuint> indicesBV;
2582                 VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "a[0][0]", error);
2583                 VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "Block", error);
2584
2585                 VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], "a[0][0][0]", error);
2586                 VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Block"], "Block", error);
2587
2588                 GLenum props3[] = { GL_NAME_LENGTH,
2589                                                         GL_TYPE,
2590                                                         GL_ARRAY_SIZE,
2591                                                         GL_BLOCK_INDEX,
2592                                                         GL_IS_ROW_MAJOR,
2593                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2594                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2595                                                         GL_REFERENCED_BY_VERTEX_SHADER,
2596                                                         GL_TOP_LEVEL_ARRAY_SIZE };
2597                 GLint expected5[] = { 11, 35666, 3, static_cast<GLint>(indicesSSB["Block"]), 0, 1, 0, 0, 5 };
2598                 VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], 9, props3, 9, expected5, error);
2599
2600                 GLenum  prop = GL_TOP_LEVEL_ARRAY_STRIDE;
2601                 GLsizei len;
2602                 GLint   res;
2603                 glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], 1, &prop, 1024, &len, &res);
2604                 if (res <= 0)
2605                 {
2606                         m_context.getTestContext().getLog()
2607                                 << tcu::TestLog::Message
2608                                 << "Call: glGetProgramResourceiv, interface: GL_BUFFER_VARIABLE, param: GL_TOP_LEVEL_ARRAY_STRIDE\n"
2609                                 << "Expected value greater than 0, got: " << res << tcu::TestLog::EndMessage;
2610                         glDeleteProgram(program);
2611                         return ERROR;
2612                 }
2613
2614                 glDeleteProgram(program);
2615                 return error;
2616         }
2617 };
2618
2619 class SeparateProgramsVertex : public SimpleShaders
2620 {
2621 public:
2622         virtual std::string Title()
2623         {
2624                 return "Separate Program Vertex Shader Test";
2625         }
2626
2627         virtual std::string ShadersDesc()
2628         {
2629                 return "vertex shader as separate shader object";
2630         }
2631
2632         virtual std::string PurposeExt()
2633         {
2634                 return "\n\n Purpose is to verify that feature works correctly when using separate_shader_objects "
2635                            "functionality.\n";
2636         }
2637
2638         virtual GLuint CreateShaderProgram(GLenum type, GLsizei count, const GLchar** strings)
2639         {
2640                 GLuint program = glCreateShaderProgramv(type, count, strings);
2641                 GLint  status  = GL_TRUE;
2642                 glGetProgramiv(program, GL_LINK_STATUS, &status);
2643                 if (status == GL_FALSE)
2644                 {
2645                         GLsizei length;
2646                         GLchar  log[1024];
2647                         glGetProgramInfoLog(program, sizeof(log), &length, log);
2648                         if (length > 1)
2649                         {
2650                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
2651                                                                                                         << log << tcu::TestLog::EndMessage;
2652                         }
2653                 }
2654                 return program;
2655         }
2656
2657         virtual long Run()
2658         {
2659                 long error = NO_ERROR;
2660
2661                 const char* srcVS = "#version 310 es                            \n"
2662                                                         "layout(location = 0) in vec4 in_vertex;    \n"
2663                                                         ""
2664                                                         "out mediump float r, g, b;                           \n"
2665                                                         "out mediump vec4 iLikePie;                           \n"
2666                                                         ""
2667                                                         "uniform mediump float u;                           \n"
2668                                                         "uniform mediump vec4 v;                            \n"
2669                                                         ""
2670                                                         "void main() {                     \n"
2671                                                         "  gl_Position = in_vertex;        \n"
2672                                                         "  r = u;                          \n"
2673                                                         "  g = 0.0;                        \n"
2674                                                         "  b = 0.0;                        \n"
2675                                                         "  iLikePie = v;                   \n"
2676                                                         "}";
2677
2678                 const GLuint vs = CreateShaderProgram(GL_VERTEX_SHADER, 1, &srcVS);
2679
2680                 VerifyGetProgramInterfaceiv(vs, GL_UNIFORM, GL_MAX_NAME_LENGTH, 2, error);
2681                 VerifyGetProgramInterfaceiv(vs, GL_UNIFORM, GL_ACTIVE_RESOURCES, 2, error);
2682                 VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 10, error);
2683                 VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
2684                 VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 12, error);
2685                 VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 5, error);
2686
2687                 std::map<std::string, GLuint> indicesU;
2688                 std::map<std::string, GLuint> indicesI;
2689                 std::map<std::string, GLuint> indicesO;
2690                 VerifyGetProgramResourceIndex(vs, GL_UNIFORM, indicesU, "u", error);
2691                 VerifyGetProgramResourceIndex(vs, GL_UNIFORM, indicesU, "v", error);
2692                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_INPUT, indicesI, "in_vertex", error);
2693                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "r", error);
2694                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "g", error);
2695                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "b", error);
2696                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "iLikePie", error);
2697                 VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "gl_Position", error);
2698
2699                 VerifyGetProgramResourceName(vs, GL_UNIFORM, indicesU["u"], "u", error);
2700                 VerifyGetProgramResourceName(vs, GL_UNIFORM, indicesU["v"], "v", error);
2701                 VerifyGetProgramResourceName(vs, GL_PROGRAM_INPUT, indicesI["in_vertex"], "in_vertex", error);
2702                 VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["r"], "r", error);
2703                 VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["g"], "g", error);
2704                 VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["b"], "b", error);
2705                 VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["iLikePie"], "iLikePie", error);
2706                 VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["gl_Position"], "gl_Position", error);
2707
2708                 VerifyGetProgramResourceLocation(vs, GL_UNIFORM, "u", glGetUniformLocation(vs, "u"), error);
2709                 VerifyGetProgramResourceLocation(vs, GL_UNIFORM, "v", glGetUniformLocation(vs, "v"), error);
2710                 VerifyGetProgramResourceLocation(vs, GL_PROGRAM_INPUT, "in_vertex", 0, error);
2711
2712                 GLenum props[] = { GL_NAME_LENGTH,
2713                                                    GL_TYPE,
2714                                                    GL_ARRAY_SIZE,
2715                                                    GL_OFFSET,
2716                                                    GL_BLOCK_INDEX,
2717                                                    GL_ARRAY_STRIDE,
2718                                                    GL_MATRIX_STRIDE,
2719                                                    GL_IS_ROW_MAJOR,
2720                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
2721                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
2722                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
2723                                                    GL_REFERENCED_BY_VERTEX_SHADER,
2724                                                    GL_LOCATION };
2725                 GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(vs, "v") };
2726                 VerifyGetProgramResourceiv(vs, GL_UNIFORM, indicesU["v"], 13, props, 13, expected, error);
2727
2728                 GLenum props2[] = { GL_NAME_LENGTH,
2729                                                         GL_TYPE,
2730                                                         GL_ARRAY_SIZE,
2731                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2732                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2733                                                         GL_REFERENCED_BY_VERTEX_SHADER,
2734                                                         GL_LOCATION };
2735                 GLint expected2[] = { 10, 35666, 1, 0, 0, 1, 0 };
2736                 VerifyGetProgramResourceiv(vs, GL_PROGRAM_INPUT, indicesI["in_vertex"], 7, props2, 7, expected2, error);
2737
2738                 GLenum props3[] = { GL_NAME_LENGTH,
2739                                                         GL_TYPE,
2740                                                         GL_ARRAY_SIZE,
2741                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2742                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2743                                                         GL_REFERENCED_BY_VERTEX_SHADER };
2744                 GLint expected3[] = { 9, 35666, 1, 0, 0, 1 };
2745                 VerifyGetProgramResourceiv(vs, GL_PROGRAM_OUTPUT, indicesO["iLikePie"], 6, props3, 6, expected3, error);
2746
2747                 glDeleteProgram(vs);
2748                 return error;
2749         }
2750 };
2751
2752 class SeparateProgramsFragment : public SeparateProgramsVertex
2753 {
2754
2755         virtual std::string Title()
2756         {
2757                 return "Separate Program Fragment Shader Test";
2758         }
2759
2760         virtual std::string ShadersDesc()
2761         {
2762                 return "fragment shader as separate shader object";
2763         }
2764
2765         virtual long Run()
2766         {
2767                 long error = NO_ERROR;
2768
2769                 const char* srcTCS = "#version 310 es                                  \n"
2770                                                          "out mediump vec4 fs_color;                       \n"
2771                                                          ""
2772                                                          "layout(location = 1) uniform mediump vec4 x;     \n"
2773                                                          ""
2774                                                          "in mediump vec4 vs_color;                        \n"
2775                                                          "void main() {                                    \n"
2776                                                          "   fs_color = vs_color + x;                      \n"
2777                                                          "}";
2778
2779                 const GLuint tcs = CreateShaderProgram(GL_FRAGMENT_SHADER, 1, &srcTCS);
2780
2781                 VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
2782                 VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
2783                 VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 9, error);
2784                 VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
2785                 VerifyGetProgramInterfaceiv(tcs, GL_UNIFORM, GL_MAX_NAME_LENGTH, 2, error);
2786                 VerifyGetProgramInterfaceiv(tcs, GL_UNIFORM, GL_ACTIVE_RESOURCES, 1, error);
2787
2788                 std::map<std::string, GLuint> indicesI;
2789                 std::map<std::string, GLuint> indicesO;
2790                 std::map<std::string, GLuint> indicesU;
2791                 VerifyGetProgramResourceIndex(tcs, GL_PROGRAM_INPUT, indicesI, "vs_color", error);
2792                 VerifyGetProgramResourceIndex(tcs, GL_PROGRAM_OUTPUT, indicesO, "fs_color", error);
2793                 VerifyGetProgramResourceIndex(tcs, GL_UNIFORM, indicesU, "x", error);
2794
2795                 VerifyGetProgramResourceName(tcs, GL_PROGRAM_INPUT, indicesI["vs_color"], "vs_color", error);
2796                 VerifyGetProgramResourceName(tcs, GL_PROGRAM_OUTPUT, indicesO["fs_color"], "fs_color", error);
2797                 VerifyGetProgramResourceName(tcs, GL_UNIFORM, indicesU["x"], "x", error);
2798
2799                 VerifyGetProgramResourceLocation(tcs, GL_UNIFORM, "x", 1, error);
2800
2801                 GLenum props2[] = { GL_NAME_LENGTH,
2802                                                         GL_TYPE,
2803                                                         GL_ARRAY_SIZE,
2804                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
2805                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
2806                                                         GL_REFERENCED_BY_VERTEX_SHADER };
2807                 GLint expected2[] = { 9, 35666, 1, 0, 1, 0 };
2808                 VerifyGetProgramResourceiv(tcs, GL_PROGRAM_INPUT, indicesI["vs_color"], 6, props2, 6, expected2, error);
2809                 VerifyGetProgramResourceiv(tcs, GL_PROGRAM_OUTPUT, indicesO["fs_color"], 6, props2, 6, expected2, error);
2810
2811                 GLenum props[] = { GL_NAME_LENGTH,
2812                                                    GL_TYPE,
2813                                                    GL_ARRAY_SIZE,
2814                                                    GL_OFFSET,
2815                                                    GL_BLOCK_INDEX,
2816                                                    GL_ARRAY_STRIDE,
2817                                                    GL_MATRIX_STRIDE,
2818                                                    GL_IS_ROW_MAJOR,
2819                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
2820                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
2821                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
2822                                                    GL_REFERENCED_BY_VERTEX_SHADER,
2823                                                    GL_LOCATION };
2824                 GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, 1 };
2825                 VerifyGetProgramResourceiv(tcs, GL_UNIFORM, indicesU["x"], 13, props, 13, expected, error);
2826
2827                 glDeleteProgram(tcs);
2828                 return error;
2829         }
2830 };
2831
2832 class UniformBlockAdvanced : public SimpleShaders
2833 {
2834         virtual std::string Title()
2835         {
2836                 return "Uniform Block Advanced Test";
2837         }
2838
2839         virtual std::string ShadersDesc()
2840         {
2841                 return "fallthrough fragment and vertex shaders with different types of uniform blocks used";
2842         }
2843
2844         virtual std::string PurposeExt()
2845         {
2846                 return "\n\n Purpose is to verify calls using GL_UNIFORM_BLOCK as an interface param and\n"
2847                            "verify results of querying offset, strides and row order.\n";
2848         }
2849
2850         virtual std::string VertexShader()
2851         {
2852                 return "#version 310 es                      \n"
2853                            "in vec4 position;                    \n"
2854                            ""
2855                            "layout(row_major) uniform SimpleBlock {   \n"
2856                            "   mat4 a;                                \n"
2857                            "   vec4 b[10];                            \n"
2858                            "};                                        \n"
2859                            ""
2860                            "void main(void)                      \n"
2861                            "{                                    \n"
2862                            "    float tmp;                       \n"
2863                            "    tmp = a[0][0] + b[0].x;          \n"
2864                            "    gl_Position = position * tmp;    \n"
2865                            "}";
2866         }
2867
2868         virtual long Run()
2869         {
2870                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2871                 glBindAttribLocation(program, 0, "position");
2872                 LinkProgram(program);
2873
2874                 long error = NO_ERROR;
2875
2876                 std::map<std::string, GLuint> indicesU;
2877                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
2878                 VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
2879
2880                 GLenum props[]  = { GL_IS_ROW_MAJOR };
2881                 GLint  expected[] = { 1 };
2882                 VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, props, 1, expected, error);
2883
2884                 GLenum  prop = GL_MATRIX_STRIDE;
2885                 GLsizei len;
2886                 GLint   res;
2887                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, 1024, &len, &res);
2888                 if (res < 1)
2889                 {
2890                         m_context.getTestContext().getLog()
2891                                 << tcu::TestLog::Message
2892                                 << "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_MATRIX_STRIDE\n"
2893                                 << "Expected value greater than 0, got " << res << tcu::TestLog::EndMessage;
2894                 }
2895                 prop = GL_OFFSET;
2896                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, 1024, &len, &res);
2897                 if (res < 0)
2898                 {
2899                         m_context.getTestContext().getLog()
2900                                 << tcu::TestLog::Message << "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_OFFSET\n"
2901                                 << "Expected value not less than 0, got " << res << tcu::TestLog::EndMessage;
2902                 }
2903                 prop = GL_ARRAY_STRIDE;
2904                 glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, 1024, &len, &res);
2905                 if (res < 1)
2906                 {
2907                         m_context.getTestContext().getLog()
2908                                 << tcu::TestLog::Message
2909                                 << "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_ARRAY_STRIDE\n"
2910                                 << "Expected value greater than 0, got " << res << tcu::TestLog::EndMessage;
2911                 }
2912
2913                 glDeleteProgram(program);
2914                 return error;
2915         }
2916 };
2917
2918 class ArrayNames : public SimpleShaders
2919 {
2920
2921         virtual std::string Title()
2922         {
2923                 return "Array Names Test";
2924         }
2925
2926         virtual std::string ShadersDesc()
2927         {
2928                 return "fallthrough fragment shader and a vertex shader with array of vec4 uniform used";
2929         }
2930
2931         virtual std::string PurposeExt()
2932         {
2933                 return "\n\n Purpose is to verify that GetProgramResourceLocation match "
2934                            "name strings correctly.\n";
2935         }
2936
2937         virtual std::string VertexShader()
2938         {
2939                 return "#version 310 es                      \n"
2940                            "in vec4 position;                    \n"
2941                            ""
2942                            "uniform mediump vec4 a[2];           \n"
2943                            ""
2944                            "void main(void)                            \n"
2945                            "{                                          \n"
2946                            "    gl_Position = position + a[0] + a[1];  \n"
2947                            "}";
2948         }
2949
2950         virtual long Run()
2951         {
2952                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
2953                 glBindAttribLocation(program, 0, "position");
2954                 LinkProgram(program);
2955
2956                 long error = NO_ERROR;
2957
2958                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", glGetUniformLocation(program, "a"), error);
2959                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0]", glGetUniformLocation(program, "a"), error);
2960                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[1]", glGetUniformLocation(program, "a[1]"), error);
2961                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[2]", -1, error);
2962                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0 + 0]", -1, error);
2963                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0+0]", -1, error);
2964                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[ 0]", -1, error);
2965                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0 ]", -1, error);
2966                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[\n0]", -1, error);
2967                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[\t0]", -1, error);
2968                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[01]", -1, error);
2969                 VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[00]", -1, error);
2970
2971                 glDeleteProgram(program);
2972                 return error;
2973         }
2974 };
2975
2976 class BuffLength : public SimpleShaders
2977 {
2978
2979         virtual std::string Title()
2980         {
2981                 return "Buff Length Test";
2982         }
2983
2984         virtual std::string ShadersDesc()
2985         {
2986                 return "fallthrough fragment shader and vertex with uniform of vec4 type used";
2987         }
2988
2989         virtual std::string PurposeExt()
2990         {
2991                 return "\n\n Purpose is to verify that bufsize of GetProgramResourceName and "
2992                            "GetProgramResourceiv is respected.\n";
2993         }
2994
2995         virtual std::string VertexShader()
2996         {
2997                 return "#version 310 es                      \n"
2998                            "in vec4 position;                    \n"
2999                            ""
3000                            "uniform mediump vec4 someLongName;         \n"
3001                            ""
3002                            "void main(void)                            \n"
3003                            "{                                          \n"
3004                            "    gl_Position = position + someLongName; \n"
3005                            "}";
3006         }
3007
3008         virtual long Run()
3009         {
3010                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
3011                 glBindAttribLocation(program, 0, "position");
3012                 LinkProgram(program);
3013
3014                 long error = NO_ERROR;
3015
3016                 GLuint  index = glGetProgramResourceIndex(program, GL_UNIFORM, "someLongName");
3017                 GLsizei length;
3018                 GLchar  buff[3] = { 'a', 'b', 'c' };
3019                 glGetProgramResourceName(program, GL_UNIFORM, index, 0, NULL, NULL);
3020                 glGetProgramResourceName(program, GL_UNIFORM, index, 0, NULL, buff);
3021                 if (buff[0] != 'a' || buff[1] != 'b' || buff[2] != 'c')
3022                 {
3023                         m_context.getTestContext().getLog()
3024                                 << tcu::TestLog::Message << "ERROR: buff has changed" << tcu::TestLog::EndMessage;
3025                         error = ERROR;
3026                 }
3027                 glGetProgramResourceName(program, GL_UNIFORM, index, 2, &length, buff);
3028                 if (buff[0] != 's' || buff[1] != '\0' || buff[2] != 'c')
3029                 {
3030                         m_context.getTestContext().getLog()
3031                                 << tcu::TestLog::Message << "ERROR: buff different then expected" << tcu::TestLog::EndMessage;
3032                         error = ERROR;
3033                 }
3034                 if (length != 1)
3035                 {
3036                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: incorrect length, expected 1, got "
3037                                                                                                 << length << tcu::TestLog::EndMessage;
3038                         error = ERROR;
3039                 }
3040
3041                 GLint  params[3] = { 1, 2, 3 };
3042                 GLenum props[]   = { GL_NAME_LENGTH,
3043                                                    GL_TYPE,
3044                                                    GL_ARRAY_SIZE,
3045                                                    GL_OFFSET,
3046                                                    GL_BLOCK_INDEX,
3047                                                    GL_ARRAY_STRIDE,
3048                                                    GL_MATRIX_STRIDE,
3049                                                    GL_IS_ROW_MAJOR,
3050                                                    GL_ATOMIC_COUNTER_BUFFER_INDEX,
3051                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
3052                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
3053                                                    GL_REFERENCED_BY_VERTEX_SHADER,
3054                                                    GL_LOCATION };
3055                 glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 0, NULL, NULL);
3056                 glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 0, NULL, params);
3057                 if (params[0] != 1 || params[1] != 2 || params[2] != 3)
3058                 {
3059                         m_context.getTestContext().getLog()
3060                                 << tcu::TestLog::Message << "ERROR: params has changed" << tcu::TestLog::EndMessage;
3061                         error = ERROR;
3062                 }
3063                 glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 2, &length, params);
3064                 if (params[0] != 13 || params[1] != 35666 || params[2] != 3)
3065                 {
3066                         m_context.getTestContext().getLog()
3067                                 << tcu::TestLog::Message << "ERROR: params has incorrect values" << tcu::TestLog::EndMessage;
3068                         error = ERROR;
3069                 }
3070                 if (length != 2)
3071                 {
3072                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: incorrect length, expected 2, got "
3073                                                                                                 << length << tcu::TestLog::EndMessage;
3074                         error = ERROR;
3075                 }
3076
3077                 glDeleteProgram(program);
3078                 return error;
3079         }
3080 };
3081
3082 class NoLocations : public SimpleShaders
3083 {
3084
3085         virtual std::string Title()
3086         {
3087                 return "No Locations Test";
3088         }
3089
3090         virtual std::string ShadersDesc()
3091         {
3092                 return "fragment and vertex shaders with no locations set";
3093         }
3094
3095         virtual std::string VertexShader()
3096         {
3097                 return "#version 310 es                      \n"
3098                            "in vec4 a;                           \n"
3099                            "in vec4 b;                           \n"
3100                            "in vec4 c;                           \n"
3101                            "in vec4 d;                           \n"
3102                            "void main(void)                      \n"
3103                            "{                                    \n"
3104                            "    gl_Position = a + b + c + d;     \n"
3105                            "}";
3106         }
3107
3108         // fragment shader outputs need an explicit location per spec
3109         virtual std::string FragmentShader()
3110         {
3111                 return "#version 310 es                \n"
3112                            "layout (location=0) out mediump vec4 a;            \n"
3113                            "layout (location=1) out mediump vec4 b;            \n"
3114                            "layout (location=2) out mediump vec4 c;            \n"
3115                            "layout (location=3) out mediump vec4 d[1];         \n"
3116                            "void main() {                  \n"
3117                            "    a = vec4(0, 1, 0, 1);      \n"
3118                            "    b = vec4(0, 1, 0, 1);      \n"
3119                            "    c = vec4(0, 1, 0, 1);      \n"
3120                            "    d[0] = vec4(0, 1, 0, 1);   \n"
3121                            "}";
3122         }
3123
3124         virtual long Run()
3125         {
3126                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
3127                 glBindAttribLocation(program, 0, "position");
3128                 glLinkProgram(program);
3129
3130                 long error = NO_ERROR;
3131
3132                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 4, error);
3133                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);
3134                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 4, error);
3135                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 5, error);
3136
3137                 std::map<std::string, GLuint> indicesI;
3138                 std::map<std::string, GLuint> indicesO;
3139                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "a", error);
3140                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "b", error);
3141                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "c", error);
3142                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "d", error);
3143                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "a", error);
3144                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "b", error);
3145                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "c", error);
3146                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "d[0]", error);
3147
3148                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["a"], "a", error);
3149                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["b"], "b", error);
3150                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["c"], "c", error);
3151                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["d"], "d", error);
3152                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["a"], "a", error);
3153                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["b"], "b", error);
3154                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["c"], "c", error);
3155                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["d[0]"], "d[0]", error);
3156
3157                 std::map<std::string, GLint> locationsI;
3158                 std::map<std::string, GLint> locationsO;
3159                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "a", error);
3160                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "b", error);
3161                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "c", error);
3162                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "d", error);
3163                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "a", error);
3164                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "b", error);
3165                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "c", error);
3166                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "d[0]", error);
3167
3168                 GLenum props[] = { GL_NAME_LENGTH,
3169                                                    GL_TYPE,
3170                                                    GL_ARRAY_SIZE,
3171                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
3172                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
3173                                                    GL_REFERENCED_BY_VERTEX_SHADER };
3174                 GLint expected[] = { 2, 35666, 1, 0, 0, 1 };
3175                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["a"], 6, props, 6, expected, error);
3176                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["b"], 6, props, 6, expected, error);
3177                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["d"], 6, props, 6, expected, error);
3178                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["c"], 6, props, 6, expected, error);
3179                 GLint expected3[] = { 2, 35666, 1, 0, 1, 0 };
3180                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["a"], 6, props, 6, expected3, error);
3181                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["b"], 6, props, 6, expected3, error);
3182                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["c"], 6, props, 6, expected3, error);
3183                 GLint expected4[] = { 5, 35666, 1, 0, 1, 0 };
3184                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["d[0]"], 6, props, 6, expected4, error);
3185
3186                 glDeleteProgram(program);
3187                 return error;
3188         }
3189 };
3190
3191 class OutputBuiltIn : public SimpleShaders
3192 {
3193
3194         virtual std::string Title()
3195         {
3196                 return "Output Built-ins Test";
3197         }
3198
3199         virtual std::string ShadersDesc()
3200         {
3201                 return "fragment shader using built-in variables and a fallthrough vertex shader";
3202         }
3203
3204         virtual std::string Expectations()
3205         {
3206                 return ".\n\n In this case we ask for information about built-in variables for the output interface.";
3207         }
3208
3209         virtual std::string FragmentShader()
3210         {
3211                 return "#version 310 es                            \n"
3212                            "void main(void)                            \n"
3213                            "{                                          \n"
3214                            "    gl_FragDepth = 0.1;                    \n"
3215                            "}";
3216         }
3217
3218         virtual long Run()
3219         {
3220                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), true);
3221
3222                 long error = NO_ERROR;
3223
3224                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
3225                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 13, error);
3226
3227                 std::map<std::string, GLuint> indices;
3228                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "gl_FragDepth", error);
3229
3230                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["gl_FragDepth"], "gl_FragDepth", error);
3231
3232                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "gl_FragDepth", -1, error);
3233
3234                 GLenum props[] = { GL_NAME_LENGTH,
3235                                                    GL_TYPE,
3236                                                    GL_ARRAY_SIZE,
3237                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
3238                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
3239                                                    GL_REFERENCED_BY_VERTEX_SHADER,
3240                                                    GL_LOCATION };
3241                 GLint expected[] = { 13, 5126, 1, 0, 1, 0, -1 };
3242                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["gl_FragDepth"], DE_LENGTH_OF_ARRAY(props),
3243                                                                    props, DE_LENGTH_OF_ARRAY(expected), expected, error);
3244
3245                 glDeleteProgram(program);
3246                 return error;
3247         }
3248 };
3249
3250 class QueryNotUsed : public SimpleShaders
3251 {
3252
3253         virtual std::string Title()
3254         {
3255                 return "Query Not Used Test";
3256         }
3257
3258         virtual std::string PassCriteria()
3259         {
3260                 return "Data from queries matches the not used program.";
3261         }
3262
3263         virtual std::string Purpose()
3264         {
3265                 return "Verify that program parameter works correctly and proper program is queried when different program is "
3266                            "used.";
3267         }
3268
3269         virtual std::string Method()
3270         {
3271                 return "Create 2 programs, use one of them and query the other, verify the results.";
3272         }
3273
3274         virtual std::string VertexShader2()
3275         {
3276                 return "#version 310 es                      \n"
3277                            "in mediump vec4 p;                   \n"
3278                            "void main(void)                      \n"
3279                            "{                                    \n"
3280                            "    gl_Position = p;                 \n"
3281                            "}";
3282         }
3283
3284         virtual std::string FragmentShader2()
3285         {
3286                 return "#version 310 es                \n"
3287                            "out mediump vec4 c;            \n"
3288                            "void main() {                  \n"
3289                            "    c = vec4(0., 1., 0., 1.);  \n"
3290                            "}";
3291         }
3292
3293         virtual long Run()
3294         {
3295                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
3296                 LinkProgram(program);
3297
3298                 GLuint program2 = CreateProgram(VertexShader2().c_str(), FragmentShader2().c_str(), false);
3299                 LinkProgram(program2);
3300                 glUseProgram(program2);
3301
3302                 long error = NO_ERROR;
3303
3304                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
3305                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
3306                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
3307                 VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 6, error);
3308
3309                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color", 0, error);
3310                 VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "position", 0, error);
3311
3312                 VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, "color", error);
3313                 VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, "position", error);
3314
3315                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", 0, error);
3316                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", 0, error);
3317
3318                 GLenum props[] = { GL_NAME_LENGTH,
3319                                                    GL_TYPE,
3320                                                    GL_ARRAY_SIZE,
3321                                                    GL_REFERENCED_BY_COMPUTE_SHADER,
3322                                                    GL_REFERENCED_BY_FRAGMENT_SHADER,
3323                                                    GL_REFERENCED_BY_VERTEX_SHADER,
3324                                                    GL_LOCATION };
3325                 GLint expected[] = { 9, 35666, 1, 0, 0, 1, 0 };
3326                 VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, DE_LENGTH_OF_ARRAY(props), props,
3327                                                                    DE_LENGTH_OF_ARRAY(expected), expected, error);
3328
3329                 GLenum props2[] = { GL_NAME_LENGTH,
3330                                                         GL_TYPE,
3331                                                         GL_ARRAY_SIZE,
3332                                                         GL_REFERENCED_BY_COMPUTE_SHADER,
3333                                                         GL_REFERENCED_BY_FRAGMENT_SHADER,
3334                                                         GL_REFERENCED_BY_VERTEX_SHADER,
3335                                                         GL_LOCATION };
3336                 GLint expected2[] = { 6, 35666, 1, 0, 1, 0, 0 };
3337                 VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, 0, 7, props2, 7, expected2, error);
3338
3339                 glDeleteProgram(program);
3340                 glDeleteProgram(program2);
3341                 return error;
3342         }
3343 };
3344
3345 class RelinkFailure : public SimpleShaders
3346 {
3347
3348         virtual std::string Title()
3349         {
3350                 return "Relink Failure Test";
3351         }
3352
3353         virtual std::string PassCriteria()
3354         {
3355                 return "INVALID_OPERATION is generated when asking for locations after failed link.";
3356         }
3357
3358         virtual std::string Purpose()
3359         {
3360                 return "Verify that queries behave correctly after failed relink of a program.";
3361         }
3362
3363         virtual std::string Method()
3364         {
3365                 return "Create a program, use it, relink with failure and then verify that INVALID_OPERATION is returned when "
3366                            "asking for locations.";
3367         }
3368
3369         virtual std::string VertexShader()
3370         {
3371                 return "#version 310 es                               \n"
3372                            "in mediump vec4 position;                     \n"
3373                            "in mediump vec3 pos;                          \n"
3374                            "void main(void)                               \n"
3375                            "{                                             \n"
3376                            "    gl_Position = position + vec4(pos, 1.);   \n"
3377                            "}";
3378         }
3379
3380         virtual long Run()
3381         {
3382                 GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
3383                 glBindAttribLocation(program, 0, "position");
3384                 glBindAttribLocation(program, 1, "pos");
3385                 LinkProgram(program);
3386
3387                 long error = NO_ERROR;
3388
3389                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "pos", 1, error);
3390                 glUseProgram(program);
3391
3392                 tcu::Vec4 v[4] = { tcu::Vec4(-1, 1, 0, 1), tcu::Vec4(-1, -1, 0, 1), tcu::Vec4(1, 1, 0, 1),
3393                                                    tcu::Vec4(1, -1, 0, 1) };
3394                 GLuint vao, vbuf;
3395                 glGenVertexArrays(1, &vao);
3396                 glBindVertexArray(vao);
3397                 glGenBuffers(1, &vbuf);
3398                 glBindBuffer(GL_ARRAY_BUFFER, vbuf);
3399                 glBufferData(GL_ARRAY_BUFFER, sizeof(v), v, GL_STATIC_DRAW);
3400                 glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0);
3401                 glEnableVertexAttribArray(0);
3402                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
3403
3404                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
3405                 glDisableVertexAttribArray(0);
3406                 glDeleteVertexArrays(1, &vao);
3407                 glBindBuffer(GL_ARRAY_BUFFER, 0);
3408                 glDeleteBuffers(1, &vbuf);
3409
3410                 glBindAttribLocation(program, 0, "pos");
3411                 glBindAttribLocation(program, 0, "position");
3412                 const char* varyings[2] = { "q", "z" };
3413                 glTransformFeedbackVaryings(program, 2, varyings, GL_INTERLEAVED_ATTRIBS);
3414                 LinkProgram(program);
3415
3416                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", -1, error);
3417                 ExpectError(GL_INVALID_OPERATION, error);
3418                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "pos", -1, error);
3419                 ExpectError(GL_INVALID_OPERATION, error);
3420                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", -1, error);
3421                 ExpectError(GL_INVALID_OPERATION, error);
3422
3423                 glDeleteProgram(program);
3424                 return error;
3425         }
3426 };
3427
3428 class LinkFailure : public SimpleShaders
3429 {
3430
3431         virtual std::string Title()
3432         {
3433                 return "Link Failure Test";
3434         }
3435
3436         virtual std::string PassCriteria()
3437         {
3438                 return "INVALID_OPERATION is generated when asking for locations after failed link.";
3439         }
3440
3441         virtual std::string Purpose()
3442         {
3443                 return "Verify that queries behave correctly after failed relink of a program with changed sources.";
3444         }
3445
3446         virtual std::string Method()
3447         {
3448                 return "Create a program, use it, relink with failure using different sources and then \n"
3449                            "verify that INVALID_OPERATION is returned when asking for locations.";
3450         }
3451
3452         virtual const char* VertexShader_prop()
3453         {
3454                 return "#version 310 es                      \n"
3455                            "in mediump vec4 posit;               \n"
3456                            "in mediump vec4 p;                   \n"
3457                            "void main(void)                      \n"
3458                            "{                                    \n"
3459                            "    gl_Position = p + posit;         \n"
3460                            "}";
3461         }
3462
3463         virtual const char* FragmentShader_prop()
3464         {
3465                 return "#version 310 es                    \n"
3466                            "out mediump vec4 color;            \n"
3467                            "void main() {                      \n"
3468                            "    color = vec4(0., 1., 0., 1.);  \n"
3469                            "}";
3470         }
3471
3472         virtual const char* VertexShader_fail()
3473         {
3474                 return "#version 310 es                      \n"
3475                            "in mediump vec4 position;            \n"
3476                            "void main(void)                      \n"
3477                            "{                                    \n"
3478                            "    gl_Position = position;          \n"
3479                            "}";
3480         }
3481
3482         virtual long Run()
3483         {
3484                 const GLuint program = glCreateProgram();
3485                 const char*  src_vs  = VertexShader_prop();
3486                 const char*  src_fs  = FragmentShader_prop();
3487                 const char*  src_vsh = VertexShader_fail();
3488
3489                 GLuint sh1 = glCreateShader(GL_VERTEX_SHADER);
3490                 glAttachShader(program, sh1);
3491                 glDeleteShader(sh1);
3492                 glShaderSource(sh1, 1, &src_vs, NULL);
3493                 glCompileShader(sh1);
3494
3495                 GLuint sh2 = glCreateShader(GL_FRAGMENT_SHADER);
3496                 glAttachShader(program, sh2);
3497                 glDeleteShader(sh2);
3498                 glShaderSource(sh2, 1, &src_fs, NULL);
3499                 glCompileShader(sh2);
3500
3501                 glBindAttribLocation(program, 0, "p");
3502                 glBindAttribLocation(program, 1, "posit");
3503                 LinkProgram(program);
3504
3505                 long error = NO_ERROR;
3506
3507                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "posit", 1, error);
3508                 glUseProgram(program);
3509
3510                 tcu::Vec4 v[4] = { tcu::Vec4(-1, 1, 0, 1), tcu::Vec4(-1, -1, 0, 1), tcu::Vec4(1, 1, 0, 1),
3511                                                    tcu::Vec4(1, -1, 0, 1) };
3512                 GLuint vao, vbuf;
3513                 glGenVertexArrays(1, &vao);
3514                 glBindVertexArray(vao);
3515                 glGenBuffers(1, &vbuf);
3516                 glBindBuffer(GL_ARRAY_BUFFER, vbuf);
3517                 glBufferData(GL_ARRAY_BUFFER, sizeof(v), v, GL_STATIC_DRAW);
3518                 glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0);
3519                 glEnableVertexAttribArray(0);
3520                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
3521
3522                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
3523                 glDisableVertexAttribArray(0);
3524                 glDeleteVertexArrays(1, &vao);
3525                 glBindBuffer(GL_ARRAY_BUFFER, 0);
3526                 glDeleteBuffers(1, &vbuf);
3527
3528                 glDetachShader(program, sh1);
3529                 GLuint vsh = glCreateShader(GL_VERTEX_SHADER);
3530                 glAttachShader(program, vsh);
3531                 glDeleteShader(vsh);
3532                 glShaderSource(vsh, 1, &src_vsh, NULL);
3533                 glCompileShader(vsh);
3534                 const char* varyings[2] = { "q", "z" };
3535                 glTransformFeedbackVaryings(program, 2, varyings, GL_INTERLEAVED_ATTRIBS);
3536                 LinkProgram(program);
3537
3538                 GLint res;
3539                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", -1, error);
3540                 ExpectError(GL_INVALID_OPERATION, error);
3541                 glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
3542                 if (res != 0 && res != 1)
3543                 {
3544                         m_context.getTestContext().getLog()
3545                                 << tcu::TestLog::Message << "Error, expected 0 or 1 active resources, got: " << res
3546                                 << tcu::TestLog::EndMessage;
3547                         error = ERROR;
3548                 }
3549                 glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, &res);
3550                 if (res != 0 && res != 9)
3551                 {
3552                         m_context.getTestContext().getLog()
3553                                 << tcu::TestLog::Message << "Error, expected 1 or 9 GL_MAX_NAME_LENGTH, got: " << res
3554                                 << tcu::TestLog::EndMessage;
3555                         error = ERROR;
3556                 }
3557                 VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", -1, error);
3558                 ExpectError(GL_INVALID_OPERATION, error);
3559
3560                 glDeleteProgram(program);
3561                 return error;
3562         }
3563 };
3564 }
3565
3566 ProgramInterfaceQueryTests::ProgramInterfaceQueryTests(glcts::Context& context)
3567         : TestCaseGroup(context, "program_interface_query", "")
3568 {
3569 }
3570
3571 ProgramInterfaceQueryTests::~ProgramInterfaceQueryTests(void)
3572 {
3573 }
3574
3575 void ProgramInterfaceQueryTests::init()
3576 {
3577         using namespace glcts;
3578         addChild(new TestSubcase(m_context, "empty-shaders", TestSubcase::Create<NoShaders>));
3579         addChild(new TestSubcase(m_context, "simple-shaders", TestSubcase::Create<SimpleShaders>));
3580         addChild(new TestSubcase(m_context, "input-types", TestSubcase::Create<InputTypes>));
3581         addChild(new TestSubcase(m_context, "input-built-in", TestSubcase::Create<InputBuiltIn>));
3582         addChild(new TestSubcase(m_context, "input-layout", TestSubcase::Create<InputLayout>));
3583         addChild(new TestSubcase(m_context, "output-layout", TestSubcase::Create<OutputLayout>));
3584         addChild(new TestSubcase(m_context, "output-built-in", TestSubcase::Create<OutputBuiltIn>));
3585         addChild(new TestSubcase(m_context, "uniform-simple", TestSubcase::Create<UniformSimple>));
3586         addChild(new TestSubcase(m_context, "uniform-types", TestSubcase::Create<UniformTypes>));
3587         addChild(new TestSubcase(m_context, "uniform-block-types", TestSubcase::Create<UniformBlockTypes>));
3588         addChild(new TestSubcase(m_context, "transform-feedback-types", TestSubcase::Create<TransformFeedbackTypes>));
3589         addChild(new TestSubcase(m_context, "atomic-counters", TestSubcase::Create<AtomicCounterSimple>));
3590         addChild(
3591                 new TestSubcase(m_context, "atomic-counters-one-buffer", TestSubcase::Create<AtomicCounterSimpleOneBuffer>));
3592         addChild(new TestSubcase(m_context, "ssb-types", TestSubcase::Create<ShaderStorageBlock>));
3593         addChild(new TestSubcase(m_context, "null-length", TestSubcase::Create<NullLength>));
3594         addChild(new TestSubcase(m_context, "arrays-of-arrays", TestSubcase::Create<ArraysOfArrays>));
3595         addChild(new TestSubcase(m_context, "top-level-array", TestSubcase::Create<TopLevelArray>));
3596         addChild(new TestSubcase(m_context, "separate-programs-vertex", TestSubcase::Create<SeparateProgramsVertex>));
3597         addChild(new TestSubcase(m_context, "separate-programs-fragment", TestSubcase::Create<SeparateProgramsFragment>));
3598         addChild(new TestSubcase(m_context, "uniform-block", TestSubcase::Create<UniformBlockAdvanced>));
3599         addChild(new TestSubcase(m_context, "array-names", TestSubcase::Create<ArrayNames>));
3600         addChild(new TestSubcase(m_context, "buff-length", TestSubcase::Create<BuffLength>));
3601         addChild(new TestSubcase(m_context, "no-locations", TestSubcase::Create<NoLocations>));
3602         addChild(new TestSubcase(m_context, "query-not-used", TestSubcase::Create<QueryNotUsed>));
3603         addChild(new TestSubcase(m_context, "relink-failure", TestSubcase::Create<RelinkFailure>));
3604         addChild(new TestSubcase(m_context, "link-failure", TestSubcase::Create<LinkFailure>));
3605         addChild(new TestSubcase(m_context, "compute-shader", TestSubcase::Create<ComputeShaderTest>));
3606         addChild(new TestSubcase(m_context, "invalid-value", TestSubcase::Create<InvalidValueTest>));
3607         addChild(new TestSubcase(m_context, "invalid-operation", TestSubcase::Create<InvalidOperationTest>));
3608         addChild(new TestSubcase(m_context, "invalid-enum", TestSubcase::Create<InvalidEnumTest>));
3609 }
3610 }