external/openglcts/modules/gl/gl4cShaderSubroutineTests.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 /**
  25  * \file  gl4cShaderSubroutineTests.cpp
  26  * \brief Implements conformance tests for "Shader Subroutine" functionality.
  27  */ /*-------------------------------------------------------------------*/
  28
  29 #include "gl4cShaderSubroutineTests.hpp"
  30 #include "gluContextInfo.hpp"
  31 #include "glwEnums.hpp"
  32 #include "glwFunctions.hpp"
  33 #include "tcuMatrix.hpp"
  34 #include <cmath>
  35 #include <cstring>
  36 #include <deMath.h>
  37
  38 using namespace glw;
  39
  40 namespace gl4cts
  41 {
  42 namespace ShaderSubroutine
  43 {
  44 /** Constructor.
  45  *
  46  * @param context CTS context.
  47  **/
  48 Utils::buffer::buffer(deqp::Context& context) : m_id(0), m_context(context)
  49 {
  50 }
  51
  52 /** Destructor
  53  *
  54  **/
  55 Utils::buffer::~buffer()
  56 {
  57         if (0 != m_id)
  58         {
  59                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
  60
  61                 gl.deleteBuffers(1, &m_id);
  62                 m_id = 0;
  63         }
  64 }
  65
  66 /** Execute BindBufferRange
  67  *
  68  * @param target <target> parameter
  69  * @param index  <index> parameter
  70  * @param offset <offset> parameter
  71  * @param size   <size> parameter
  72  **/
  73 void Utils::buffer::bindRange(glw::GLenum target, glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size)
  74 {
  75         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
  76
  77         gl.bindBufferRange(target, index, m_id, offset, size);
  78         GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange");
  79 }
  80
  81 /** Execute GenBuffer
  82  *
  83  **/
  84 void Utils::buffer::generate()
  85 {
  86         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
  87
  88         gl.genBuffers(1, &m_id);
  89         GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");
  90 }
  91
  92 /** Execute BufferData
  93  *
  94  * @param target <target> parameter
  95  * @param size   <size> parameter
  96  * @param data   <data> parameter
  97  * @param usage  <usage> parameter
  98  **/
  99 void Utils::buffer::update(glw::GLenum target, glw::GLsizeiptr size, glw::GLvoid* data, glw::GLenum usage)
 100 {
 101         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 102
 103         gl.bindBuffer(target, m_id);
 104         GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
 105
 106         gl.bufferData(target, size, data, usage);
 107         GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
 108 }
 109
 110 /** Constructor
 111  *
 112  * @param context CTS context
 113  **/
 114 Utils::framebuffer::framebuffer(deqp::Context& context) : m_id(0), m_context(context)
 115 {
 116         /* Nothing to be done here */
 117 }
 118
 119 /** Destructor
 120  *
 121  **/
 122 Utils::framebuffer::~framebuffer()
 123 {
 124         if (0 != m_id)
 125         {
 126                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 127
 128                 gl.deleteFramebuffers(1, &m_id);
 129                 m_id = 0;
 130         }
 131 }
 132
 133 /** Attach texture to specified attachment
 134  *
 135  * @param attachment Attachment
 136  * @param texture_id Texture id
 137  * @param width      Texture width
 138  * @param height     Texture height
 139  **/
 140 void Utils::framebuffer::attachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width,
 141                                                                            glw::GLuint height)
 142 {
 143         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 144
 145         bind();
 146
 147         gl.bindTexture(GL_TEXTURE_2D, texture_id);
 148         GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
 149
 150         gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, GL_TEXTURE_2D, texture_id, 0 /* level */);
 151
 152         GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D");
 153
 154         gl.viewport(0 /* x */, 0 /* y */, width, height);
 155         GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport");
 156 }
 157
 158 /** Binds framebuffer to DRAW_FRAMEBUFFER
 159  *
 160  **/
 161 void Utils::framebuffer::bind()
 162 {
 163         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 164
 165         gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_id);
 166         GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer");
 167 }
 168
 169 /** Clear framebuffer
 170  *
 171  * @param mask <mask> parameter of glClear. Decides which shall be cleared
 172  **/
 173 void Utils::framebuffer::clear(glw::GLenum mask)
 174 {
 175         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 176
 177         gl.clear(mask);
 178         GLU_EXPECT_NO_ERROR(gl.getError(), "Clear");
 179 }
 180
 181 /** Specifie clear color
 182  *
 183  * @param red   Red channel
 184  * @param green Green channel
 185  * @param blue  Blue channel
 186  * @param alpha Alpha channel
 187  **/
 188 void Utils::framebuffer::clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 189 {
 190         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 191
 192         gl.clearColor(red, green, blue, alpha);
 193         GLU_EXPECT_NO_ERROR(gl.getError(), "ClearColor");
 194 }
 195
 196 /** Generate framebuffer
 197  *
 198  **/
 199 void Utils::framebuffer::generate()
 200 {
 201         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 202
 203         gl.genFramebuffers(1, &m_id);
 204         GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers");
 205 }
 206
 207 const glw::GLenum Utils::program::ARB_COMPUTE_SHADER = 0x91B9;
 208
 209 /** Constructor.
 210  *
 211  * @param context CTS context.
 212  **/
 213 Utils::program::program(deqp::Context& context)
 214         : m_compute_shader_id(0)
 215         , m_fragment_shader_id(0)
 216         , m_geometry_shader_id(0)
 217         , m_program_object_id(0)
 218         , m_tesselation_control_shader_id(0)
 219         , m_tesselation_evaluation_shader_id(0)
 220         , m_vertex_shader_id(0)
 221         , m_context(context)
 222 {
 223         /* Nothing to be done here */
 224 }
 225
 226 /** Destructor
 227  *
 228  **/
 229 Utils::program::~program()
 230 {
 231         remove();
 232 }
 233
 234 /** Build program
 235  *
 236  * @param compute_shader_code                Compute shader source code
 237  * @param fragment_shader_code               Fragment shader source code
 238  * @param geometry_shader_code               Geometry shader source code
 239  * @param tesselation_control_shader_code    Tesselation control shader source code
 240  * @param tesselation_evaluation_shader_code Tesselation evaluation shader source code
 241  * @param vertex_shader_code                 Vertex shader source code
 242  * @param varying_names                      Array of strings containing names of varyings to be captured with transfrom feedback
 243  * @param n_varying_names                    Number of varyings to be captured with transfrom feedback
 244  * @param is_separable                       Selects if monolithis or separable program should be built. Defaults to false
 245  **/
 246 void Utils::program::build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code,
 247                                                    const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code,
 248                                                    const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code,
 249                                                    const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable)
 250 {
 251         /* GL entry points */
 252         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 253
 254         /* Create shader objects and compile */
 255         if (0 != compute_shader_code)
 256         {
 257                 m_compute_shader_id = gl.createShader(ARB_COMPUTE_SHADER);
 258                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 259
 260                 compile(m_compute_shader_id, compute_shader_code);
 261         }
 262
 263         if (0 != fragment_shader_code)
 264         {
 265                 m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
 266                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 267
 268                 compile(m_fragment_shader_id, fragment_shader_code);
 269         }
 270
 271         if (0 != geometry_shader_code)
 272         {
 273                 m_geometry_shader_id = gl.createShader(GL_GEOMETRY_SHADER);
 274                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 275
 276                 compile(m_geometry_shader_id, geometry_shader_code);
 277         }
 278
 279         if (0 != tesselation_control_shader_code)
 280         {
 281                 m_tesselation_control_shader_id = gl.createShader(GL_TESS_CONTROL_SHADER);
 282                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 283
 284                 compile(m_tesselation_control_shader_id, tesselation_control_shader_code);
 285         }
 286
 287         if (0 != tesselation_evaluation_shader_code)
 288         {
 289                 m_tesselation_evaluation_shader_id = gl.createShader(GL_TESS_EVALUATION_SHADER);
 290                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 291
 292                 compile(m_tesselation_evaluation_shader_id, tesselation_evaluation_shader_code);
 293         }
 294
 295         if (0 != vertex_shader_code)
 296         {
 297                 m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER);
 298                 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");
 299
 300                 compile(m_vertex_shader_id, vertex_shader_code);
 301         }
 302
 303         /* Create program object */
 304         m_program_object_id = gl.createProgram();
 305         GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram");
 306
 307         /* Set up captyured varyings' names */
 308         if (0 != n_varying_names)
 309         {
 310                 gl.transformFeedbackVaryings(m_program_object_id, n_varying_names, varying_names, GL_INTERLEAVED_ATTRIBS);
 311                 GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings");
 312         }
 313
 314         /* Set separable parameter */
 315         if (true == is_separable)
 316         {
 317                 gl.programParameteri(m_program_object_id, GL_PROGRAM_SEPARABLE, GL_TRUE);
 318                 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramParameteri");
 319         }
 320
 321         /* Link program */
 322         link();
 323 }
 324
 325 /** Compile shader
 326  *
 327  * @param shader_id   Shader object id
 328  * @param shader_code Shader source code
 329  **/
 330 void Utils::program::compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const
 331 {
 332         /* GL entry points */
 333         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 334
 335         /* Compilation status */
 336         glw::GLint status = GL_FALSE;
 337
 338         /* Set source code */
 339         gl.shaderSource(shader_id, 1 /* count */, &shader_code, 0);
 340         GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource");
 341
 342         /* Compile */
 343         gl.compileShader(shader_id);
 344         GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader");
 345
 346         /* Get compilation status */
 347         gl.getShaderiv(shader_id, GL_COMPILE_STATUS, &status);
 348         GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");
 349
 350         /* Log compilation error */
 351         if (GL_TRUE != status)
 352         {
 353                 glw::GLint                               length = 0;
 354                 std::vector<glw::GLchar> message;
 355
 356                 /* Error log length */
 357                 gl.getShaderiv(shader_id, GL_INFO_LOG_LENGTH, &length);
 358                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");
 359
 360                 /* Prepare storage */
 361                 message.resize(length);
 362
 363                 /* Get error log */
 364                 gl.getShaderInfoLog(shader_id, length, 0, &message[0]);
 365                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog");
 366
 367                 /* Log */
 368                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to compile shader:\n"
 369                                                                                         << &message[0] << "\nShader source\n"
 370                                                                                         << shader_code << tcu::TestLog::EndMessage;
 371
 372                 TCU_FAIL("Failed to compile shader");
 373         }
 374 }
 375
 376 /** Checks whether the tested driver supports GL_ARB_get_program_binary
 377  *
 378  *  @return true if the extension is supported and, also, at least one binary format.
 379  **/
 380 bool Utils::program::isProgramBinarySupported() const
 381 {
 382         glw::GLint n_program_binary_formats = 0;
 383
 384         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 385
 386         if (m_context.getContextInfo().isExtensionSupported("GL_ARB_get_program_binary"))
 387         {
 388                 gl.getIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &n_program_binary_formats);
 389                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed.");
 390         }
 391
 392         return n_program_binary_formats > 0;
 393 }
 394
 395 /** Create program from provided binary
 396  *
 397  * @param binary        Buffer with binary form of program
 398  * @param binary_format Format of <binary> data
 399  **/
 400 void Utils::program::createFromBinary(const std::vector<GLubyte>& binary, GLenum binary_format)
 401 {
 402         /* GL entry points */
 403         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 404
 405         /* Create program object */
 406         m_program_object_id = gl.createProgram();
 407         GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram");
 408
 409         gl.programBinary(m_program_object_id, binary_format, &binary[0], (GLsizei)binary.size());
 410         GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramBinary");
 411 }
 412
 413 /** Get binary form of program
 414  *
 415  * @param binary        Buffer for binary data
 416  * @param binary_format Format of binary data
 417  **/
 418 void Utils::program::getBinary(std::vector<GLubyte>& binary, GLenum& binary_format) const
 419 {
 420         /* GL entry points */
 421         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 422
 423         /* Get binary size */
 424         GLint length = 0;
 425         gl.getProgramiv(m_program_object_id, GL_PROGRAM_BINARY_LENGTH, &length);
 426         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");
 427
 428         /* Allocate storage */
 429         binary.resize(length);
 430
 431         /* Get binary */
 432         gl.getProgramBinary(m_program_object_id, (GLsizei)binary.size(), &length, &binary_format, &binary[0]);
 433         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramBinary");
 434 }
 435
 436 /** Get subroutine index
 437  *
 438  * @param subroutine_name Subroutine name
 439  *
 440  * @return Index of subroutine
 441  **/
 442 GLuint Utils::program::getSubroutineIndex(const glw::GLchar* subroutine_name, glw::GLenum shader_stage) const
 443 {
 444         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
 445         GLuint                            index = -1;
 446
 447         index = gl.getSubroutineIndex(m_program_object_id, shader_stage, subroutine_name);
 448         GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex");
 449
 450         if (GL_INVALID_INDEX == index)
 451         {
 452                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine: " << subroutine_name
 453                                                                                         << " is not available" << tcu::TestLog::EndMessage;
 454
 455                 TCU_FAIL("Subroutine is not available");
 456         }
 457
 458         return index;
 459 }
 460
 461 /** Get subroutine uniform location
 462  *
 463  * @param uniform_name Subroutine uniform name
 464  *
 465  * @return Location of subroutine uniform
 466  **/
 467 GLint Utils::program::getSubroutineUniformLocation(const glw::GLchar* uniform_name, glw::GLenum shader_stage) const
 468 {
 469         const glw::Functions& gl           = m_context.getRenderContext().getFunctions();
 470         GLint                             location = -1;
 471
 472         location = gl.getSubroutineUniformLocation(m_program_object_id, shader_stage, uniform_name);
 473         GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation");
 474
 475         if (-1 == location)
 476         {
 477                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine uniform: " << uniform_name
 478                                                                                         << " is not available" << tcu::TestLog::EndMessage;
 479
 480                 TCU_FAIL("Subroutine uniform is not available");
 481         }
 482
 483         return location;
 484 }
 485
 486 /** Get uniform location
 487  *
 488  * @param uniform_name Subroutine uniform name
 489  *
 490  * @return Location of uniform
 491  **/
 492 GLint Utils::program::getUniformLocation(const glw::GLchar* uniform_name) const
 493 {
 494         const glw::Functions& gl           = m_context.getRenderContext().getFunctions();
 495         GLint                             location = -1;
 496
 497         location = gl.getUniformLocation(m_program_object_id, uniform_name);
 498         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation");
 499
 500         if (-1 == location)
 501         {
 502                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Uniform: " << uniform_name
 503                                                                                         << " is not available" << tcu::TestLog::EndMessage;
 504
 505                 TCU_FAIL("Uniform is not available");
 506         }
 507
 508         return location;
 509 }
 510
 511 /** Attach shaders and link program
 512  *
 513  **/
 514 void Utils::program::link() const
 515 {
 516         /* GL entry points */
 517         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 518
 519         /* Link status */
 520         glw::GLint status = GL_FALSE;
 521
 522         /* Attach shaders */
 523         if (0 != m_compute_shader_id)
 524         {
 525                 gl.attachShader(m_program_object_id, m_compute_shader_id);
 526                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 527         }
 528
 529         if (0 != m_fragment_shader_id)
 530         {
 531                 gl.attachShader(m_program_object_id, m_fragment_shader_id);
 532                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 533         }
 534
 535         if (0 != m_geometry_shader_id)
 536         {
 537                 gl.attachShader(m_program_object_id, m_geometry_shader_id);
 538                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 539         }
 540
 541         if (0 != m_tesselation_control_shader_id)
 542         {
 543                 gl.attachShader(m_program_object_id, m_tesselation_control_shader_id);
 544                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 545         }
 546
 547         if (0 != m_tesselation_evaluation_shader_id)
 548         {
 549                 gl.attachShader(m_program_object_id, m_tesselation_evaluation_shader_id);
 550                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 551         }
 552
 553         if (0 != m_vertex_shader_id)
 554         {
 555                 gl.attachShader(m_program_object_id, m_vertex_shader_id);
 556                 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
 557         }
 558
 559         /* Link */
 560         gl.linkProgram(m_program_object_id);
 561         GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram");
 562
 563         /* Get link status */
 564         gl.getProgramiv(m_program_object_id, GL_LINK_STATUS, &status);
 565         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");
 566
 567         /* Log link error */
 568         if (GL_TRUE != status)
 569         {
 570                 glw::GLint                               length = 0;
 571                 std::vector<glw::GLchar> message;
 572
 573                 /* Get error log length */
 574                 gl.getProgramiv(m_program_object_id, GL_INFO_LOG_LENGTH, &length);
 575                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");
 576
 577                 message.resize(length);
 578
 579                 /* Get error log */
 580                 gl.getProgramInfoLog(m_program_object_id, length, 0, &message[0]);
 581                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog");
 582
 583                 /* Log */
 584                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to link program:\n"
 585                                                                                         << &message[0] << tcu::TestLog::EndMessage;
 586
 587                 TCU_FAIL("Failed to link program");
 588         }
 589 }
 590
 591 /** Delete program object and all attached shaders
 592  *
 593  **/
 594 void Utils::program::remove()
 595 {
 596         /* GL entry points */
 597         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 598
 599         /* Make sure program object is no longer used by GL */
 600         gl.useProgram(0);
 601
 602         /* Clean program object */
 603         if (0 != m_program_object_id)
 604         {
 605                 gl.deleteProgram(m_program_object_id);
 606                 m_program_object_id = 0;
 607         }
 608
 609         /* Clean shaders */
 610         if (0 != m_compute_shader_id)
 611         {
 612                 gl.deleteShader(m_compute_shader_id);
 613                 m_compute_shader_id = 0;
 614         }
 615
 616         if (0 != m_fragment_shader_id)
 617         {
 618                 gl.deleteShader(m_fragment_shader_id);
 619                 m_fragment_shader_id = 0;
 620         }
 621
 622         if (0 != m_geometry_shader_id)
 623         {
 624                 gl.deleteShader(m_geometry_shader_id);
 625                 m_geometry_shader_id = 0;
 626         }
 627
 628         if (0 != m_tesselation_control_shader_id)
 629         {
 630                 gl.deleteShader(m_tesselation_control_shader_id);
 631                 m_tesselation_control_shader_id = 0;
 632         }
 633
 634         if (0 != m_tesselation_evaluation_shader_id)
 635         {
 636                 gl.deleteShader(m_tesselation_evaluation_shader_id);
 637                 m_tesselation_evaluation_shader_id = 0;
 638         }
 639
 640         if (0 != m_vertex_shader_id)
 641         {
 642                 gl.deleteShader(m_vertex_shader_id);
 643                 m_vertex_shader_id = 0;
 644         }
 645 }
 646
 647 /** Execute UseProgram
 648  *
 649  **/
 650 void Utils::program::use() const
 651 {
 652         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 653
 654         gl.useProgram(m_program_object_id);
 655         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");
 656 }
 657
 658 /** Constructor.
 659  *
 660  * @param context CTS context.
 661  **/
 662 Utils::texture::texture(deqp::Context& context) : m_id(0), m_context(context)
 663 {
 664         /* Nothing to done here */
 665 }
 666
 667 /** Destructor
 668  *
 669  **/
 670 Utils::texture::~texture()
 671 {
 672         if (0 != m_id)
 673         {
 674                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 675
 676                 gl.deleteTextures(1, &m_id);
 677                 m_id = 0;
 678         }
 679 }
 680
 681 /** Bind texture to GL_TEXTURE_2D
 682  *
 683  **/
 684 void Utils::texture::bind()
 685 {
 686         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 687
 688         gl.bindTexture(GL_TEXTURE_2D, m_id);
 689         GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
 690 }
 691
 692 /** Create 2d texture
 693  *
 694  * @param width           Width of texture
 695  * @param height          Height of texture
 696  * @param internal_format Internal format of texture
 697  **/
 698 void Utils::texture::create(glw::GLuint width, glw::GLuint height, glw::GLenum internal_format)
 699 {
 700         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 701
 702         gl.genTextures(1, &m_id);
 703         GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures");
 704
 705         bind();
 706
 707         gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, internal_format, width, height);
 708         GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D");
 709 }
 710
 711 /** Get contents of texture
 712  *
 713  * @param format   Format of image
 714  * @param type     Type of image
 715  * @param out_data Buffer for image
 716  **/
 717 void Utils::texture::get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data)
 718 {
 719         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 720
 721         bind();
 722
 723         gl.getTexImage(GL_TEXTURE_2D, 0, format, type, out_data);
 724         GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");
 725 }
 726
 727 /** Update contents of texture
 728  *
 729  * @param width  Width of texture
 730  * @param height Height of texture
 731  * @param format Format of data
 732  * @param type   Type of data
 733  * @param data   Buffer with image
 734  **/
 735 void Utils::texture::update(glw::GLuint width, glw::GLuint height, glw::GLenum format, glw::GLenum type,
 736                                                         glw::GLvoid* data)
 737 {
 738         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 739
 740         bind();
 741
 742         gl.texSubImage2D(GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, width, height, format, type, data);
 743         GLU_EXPECT_NO_ERROR(gl.getError(), "TexSubImage2D");
 744 }
 745
 746 /** Constructor.
 747  *
 748  * @param context CTS context.
 749  **/
 750 Utils::vertexArray::vertexArray(deqp::Context& context) : m_id(0), m_context(context)
 751 {
 752 }
 753
 754 /** Destructor
 755  *
 756  **/
 757 Utils::vertexArray::~vertexArray()
 758 {
 759         if (0 != m_id)
 760         {
 761                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 762
 763                 gl.deleteVertexArrays(1, &m_id);
 764
 765                 m_id = 0;
 766         }
 767 }
 768
 769 /** Execute BindVertexArray
 770  *
 771  **/
 772 void Utils::vertexArray::bind()
 773 {
 774         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 775
 776         gl.bindVertexArray(m_id);
 777         GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray");
 778 }
 779
 780 /** Execute GenVertexArrays
 781  *
 782  **/
 783 void Utils::vertexArray::generate()
 784 {
 785         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 786
 787         gl.genVertexArrays(1, &m_id);
 788         GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays");
 789 }
 790
 791 /** Builds a program object consisting of up to 5 shader stages
 792  *  (vertex/tessellation control/tessellation evaluation/geometry/fragment).
 793  *  The shaders are attached to the program object, then compiled. Finally,
 794  *  the program object is linked.
 795  *
 796  *  XFB can be optionally configured for the program object.
 797  *
 798  *  Should an error be reported by GL implementation, a TestError
 799  *  exception will be thrown.
 800  *
 801  *  @param gl             OpenGL functions from the active rendering context.
 802  *  @param vs_body        Body to use for the vertex shader. Can be an empty string.
 803  *  @param tc_body        Body to use for the tessellation control shader. Can be
 804  *                        an empty string.
 805  *  @param te_body        Body to use for the tessellation evaluation shader. Can be
 806  *                        an empty string.
 807  *  @param gs_body        Body to use for the geometry shader. Can be an empty string.
 808  *  @param fs_body        Body to use for the fragment shader. Can be an empty string.
 809  *  @param xfb_varyings   An array of names of varyings to use for XFB. Can be NULL.
 810  *  @param n_xfb_varyings Amount of XFB varyings defined in @param xfb_varyings.Can be 0.
 811  *  @param out_vs_id      Deref will be used to store GL id of a generated vertex shader.
 812  *                        Can be NULL in which case no vertex shader will be used for the
 813  *                        program object.
 814  *  @param out_tc_id      Deref will be used to store GL id of a generated tess control shader.
 815  *                        Can be NULL in which case no tess control shader will be used for the
 816  *                        program object.
 817  *  @param out_te_id      Deref will be used to store GL id of a generated tess evaluation shader.
 818  *                        Can be NULL in which case no tess evaluation shader will be used for the
 819  *                        program object.
 820  *  @param out_gs_id      Deref will be used to store GL id of a generated geometry shader.
 821  *                        Can be NULL in which case no geometry shader will be used for the
 822  *                        program object.
 823  *  @param out_fs_id      Deref will be used to store GL id of a generated fragment shader.
 824  *                        Can be NULL in which case no fragment shader will be used for the
 825  *                        program object.
 826  *  @param out_po_id      Deref will be used to store GL id of a generated program object.
 827  *                        Must not be NULL.
 828  *
 829  *  @return true if the program was built successfully, false otherwise.
 830  *  */
 831 bool Utils::buildProgram(const glw::Functions& gl, const std::string& vs_body, const std::string& tc_body,
 832                                                  const std::string& te_body, const std::string& gs_body, const std::string& fs_body,
 833                                                  const glw::GLchar** xfb_varyings, const unsigned int& n_xfb_varyings, glw::GLuint* out_vs_id,
 834                                                  glw::GLuint* out_tc_id, glw::GLuint* out_te_id, glw::GLuint* out_gs_id, glw::GLuint* out_fs_id,
 835                                                  glw::GLuint* out_po_id)
 836 {
 837         bool result = false;
 838
 839         /* Link the program object */
 840         glw::GLint link_status = GL_FALSE;
 841
 842         /* Create objects, set up shader bodies and attach all requested shaders to the program object */
 843         *out_po_id = gl.createProgram();
 844         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed.");
 845
 846         if (out_vs_id != DE_NULL)
 847         {
 848                 const char* vs_body_raw_ptr = vs_body.c_str();
 849
 850                 *out_vs_id = gl.createShader(GL_VERTEX_SHADER);
 851                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
 852
 853                 gl.attachShader(*out_po_id, *out_vs_id);
 854                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
 855
 856                 gl.shaderSource(*out_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */);
 857                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
 858         }
 859
 860         if (out_tc_id != DE_NULL)
 861         {
 862                 const char* tc_body_raw_ptr = tc_body.c_str();
 863
 864                 *out_tc_id = gl.createShader(GL_TESS_CONTROL_SHADER);
 865                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
 866
 867                 gl.attachShader(*out_po_id, *out_tc_id);
 868                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
 869
 870                 gl.shaderSource(*out_tc_id, 1 /* count */, &tc_body_raw_ptr, DE_NULL /* length */);
 871                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
 872         }
 873
 874         if (out_te_id != DE_NULL)
 875         {
 876                 const char* te_body_raw_ptr = te_body.c_str();
 877
 878                 *out_te_id = gl.createShader(GL_TESS_EVALUATION_SHADER);
 879                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
 880
 881                 gl.attachShader(*out_po_id, *out_te_id);
 882                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
 883
 884                 gl.shaderSource(*out_te_id, 1 /* count */, &te_body_raw_ptr, DE_NULL /* length */);
 885                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
 886         }
 887
 888         if (out_gs_id != DE_NULL)
 889         {
 890                 const char* gs_body_raw_ptr = gs_body.c_str();
 891
 892                 *out_gs_id = gl.createShader(GL_GEOMETRY_SHADER);
 893                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
 894
 895                 gl.attachShader(*out_po_id, *out_gs_id);
 896                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
 897
 898                 gl.shaderSource(*out_gs_id, 1 /* count */, &gs_body_raw_ptr, DE_NULL /* length */);
 899                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
 900         }
 901
 902         if (out_fs_id != DE_NULL)
 903         {
 904                 const char* fs_body_raw_ptr = fs_body.c_str();
 905
 906                 *out_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
 907                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
 908
 909                 gl.attachShader(*out_po_id, *out_fs_id);
 910                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
 911
 912                 gl.shaderSource(*out_fs_id, 1 /* count */, &fs_body_raw_ptr, DE_NULL /* length */);
 913                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
 914         }
 915
 916         /* Compile all shaders */
 917         const glw::GLuint so_ids[] = { (out_vs_id != DE_NULL) ? *out_vs_id : 0, (out_tc_id != DE_NULL) ? *out_tc_id : 0,
 918                                                                    (out_te_id != DE_NULL) ? *out_te_id : 0, (out_gs_id != DE_NULL) ? *out_gs_id : 0,
 919                                                                    (out_fs_id != DE_NULL) ? *out_fs_id : 0 };
 920         const unsigned int n_so_ids = sizeof(so_ids) / sizeof(so_ids[0]);
 921
 922         for (unsigned int n_so_id = 0; n_so_id < n_so_ids; ++n_so_id)
 923         {
 924                 glw::GLuint so_id = so_ids[n_so_id];
 925
 926                 if (so_id != 0)
 927                 {
 928                         glw::GLint compile_status = GL_FALSE;
 929
 930                         gl.compileShader(so_id);
 931                         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
 932
 933                         gl.getShaderiv(so_id, GL_COMPILE_STATUS, &compile_status);
 934                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
 935
 936                         if (compile_status != GL_TRUE)
 937                         {
 938                                 goto end;
 939                         }
 940                 } /* if (so_id != 0) */
 941         }        /* for (all shader objects) */
 942
 943         /* Set up XFB */
 944         if (xfb_varyings != NULL)
 945         {
 946                 gl.transformFeedbackVaryings(*out_po_id, n_xfb_varyings, xfb_varyings, GL_INTERLEAVED_ATTRIBS);
 947                 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed.");
 948         }
 949
 950         gl.linkProgram(*out_po_id);
 951         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed.");
 952
 953         gl.getProgramiv(*out_po_id, GL_LINK_STATUS, &link_status);
 954         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
 955
 956         if (link_status != GL_TRUE)
 957         {
 958                 goto end;
 959         }
 960
 961         /* All done */
 962         result = true;
 963
 964 end:
 965         return result;
 966 }
 967
 968 /** Retrieves base variable type for user-specified variable type
 969  *  (eg. float for vec4)
 970  *
 971  *  @param variable_type Variable type to use for the query.
 972  *
 973  *  @return As per description.
 974  **/
 975 Utils::_variable_type Utils::getBaseVariableType(const _variable_type& variable_type)
 976 {
 977         _variable_type result = VARIABLE_TYPE_UNKNOWN;
 978
 979         switch (variable_type)
 980         {
 981         case VARIABLE_TYPE_BOOL:
 982         case VARIABLE_TYPE_BVEC2:
 983         case VARIABLE_TYPE_BVEC3:
 984         case VARIABLE_TYPE_BVEC4:
 985         {
 986                 result = VARIABLE_TYPE_BOOL;
 987
 988                 break;
 989         }
 990
 991         case VARIABLE_TYPE_DOUBLE:
 992         case VARIABLE_TYPE_DVEC2:
 993         case VARIABLE_TYPE_DVEC3:
 994         case VARIABLE_TYPE_DVEC4:
 995         {
 996                 result = VARIABLE_TYPE_DOUBLE;
 997
 998                 break;
 999         }
1000
1001         case VARIABLE_TYPE_FLOAT:
1002         case VARIABLE_TYPE_MAT2:
1003         case VARIABLE_TYPE_MAT2X3:
1004         case VARIABLE_TYPE_MAT2X4:
1005         case VARIABLE_TYPE_MAT3:
1006         case VARIABLE_TYPE_MAT3X2:
1007         case VARIABLE_TYPE_MAT3X4:
1008         case VARIABLE_TYPE_MAT4:
1009         case VARIABLE_TYPE_MAT4X2:
1010         case VARIABLE_TYPE_MAT4X3:
1011         case VARIABLE_TYPE_VEC2:
1012         case VARIABLE_TYPE_VEC3:
1013         case VARIABLE_TYPE_VEC4:
1014         {
1015                 result = VARIABLE_TYPE_FLOAT;
1016
1017                 break;
1018         }
1019
1020         case VARIABLE_TYPE_INT:
1021         case VARIABLE_TYPE_IVEC2:
1022         case VARIABLE_TYPE_IVEC3:
1023         case VARIABLE_TYPE_IVEC4:
1024         {
1025                 result = VARIABLE_TYPE_INT;
1026
1027                 break;
1028         }
1029
1030         case VARIABLE_TYPE_UINT:
1031         case VARIABLE_TYPE_UVEC2:
1032         case VARIABLE_TYPE_UVEC3:
1033         case VARIABLE_TYPE_UVEC4:
1034         {
1035                 result = VARIABLE_TYPE_UINT;
1036
1037                 break;
1038         }
1039
1040         default:
1041         {
1042                 TCU_FAIL("Unrecognized variable type");
1043         }
1044         } /* switch (variable_type) */
1045
1046         return result;
1047 }
1048
1049 /** Retrieves size of a single component (in bytes) for user-specified
1050  *  variable type.
1051  *
1052  *  @param variable_type Variable type to use for the query.
1053  *
1054  *  @return As per description.
1055  **/
1056 unsigned int Utils::getComponentSizeForVariableType(const _variable_type& variable_type)
1057 {
1058         _variable_type base_variable_type = getBaseVariableType(variable_type);
1059         unsigned int   result                     = 0;
1060
1061         switch (base_variable_type)
1062         {
1063         case VARIABLE_TYPE_BOOL:
1064                 result = sizeof(bool);
1065                 break;
1066         case VARIABLE_TYPE_DOUBLE:
1067                 result = sizeof(double);
1068                 break;
1069         case VARIABLE_TYPE_FLOAT:
1070                 result = sizeof(float);
1071                 break;
1072         case VARIABLE_TYPE_INT:
1073                 result = sizeof(int);
1074                 break;
1075         case VARIABLE_TYPE_UINT:
1076                 result = sizeof(unsigned int);
1077                 break;
1078
1079         default:
1080         {
1081                 TCU_FAIL("Unrecognized base variable type");
1082         }
1083         } /* switch (variable_type) */
1084
1085         return result;
1086 }
1087
1088 /** Retrieves a GLenum value corresponding to internal shader stage
1089  *  representation.
1090  *
1091  *  @param shader_stage Shader stage to user for the query.
1092  *
1093  *  @return Requested value or GL_NONE if the stage was not recognized.
1094  **/
1095 glw::GLenum Utils::getGLenumForShaderStage(const _shader_stage& shader_stage)
1096 {
1097         glw::GLenum result = GL_NONE;
1098
1099         switch (shader_stage)
1100         {
1101         case SHADER_STAGE_VERTEX:
1102                 result = GL_VERTEX_SHADER;
1103                 break;
1104         case SHADER_STAGE_TESSELLATION_CONTROL:
1105                 result = GL_TESS_CONTROL_SHADER;
1106                 break;
1107         case SHADER_STAGE_TESSELLATION_EVALUATION:
1108                 result = GL_TESS_EVALUATION_SHADER;
1109                 break;
1110         case SHADER_STAGE_GEOMETRY:
1111                 result = GL_GEOMETRY_SHADER;
1112                 break;
1113         case SHADER_STAGE_FRAGMENT:
1114                 result = GL_FRAGMENT_SHADER;
1115                 break;
1116
1117         default:
1118         {
1119                 TCU_FAIL("Unrecognized shader stage requested");
1120         }
1121         } /* switch (shader_stage) */
1122
1123         return result;
1124 }
1125
1126 /** Retrieves number of components that user-specified variable type supports.
1127  *
1128  *  @param variable_type GLSL variable type to use for the query.
1129  *
1130  *  @return As per description.
1131  **/
1132 unsigned int Utils::getNumberOfComponentsForVariableType(const _variable_type& variable_type)
1133 {
1134         unsigned int result = 0;
1135
1136         switch (variable_type)
1137         {
1138         case VARIABLE_TYPE_BOOL:
1139         case VARIABLE_TYPE_DOUBLE:
1140         case VARIABLE_TYPE_FLOAT:
1141         case VARIABLE_TYPE_INT:
1142         case VARIABLE_TYPE_UINT:
1143         {
1144                 result = 1;
1145
1146                 break;
1147         }
1148
1149         case VARIABLE_TYPE_BVEC2:
1150         case VARIABLE_TYPE_DVEC2:
1151         case VARIABLE_TYPE_IVEC2:
1152         case VARIABLE_TYPE_UVEC2:
1153         case VARIABLE_TYPE_VEC2:
1154         {
1155                 result = 2;
1156
1157                 break;
1158         }
1159
1160         case VARIABLE_TYPE_BVEC3:
1161         case VARIABLE_TYPE_DVEC3:
1162         case VARIABLE_TYPE_IVEC3:
1163         case VARIABLE_TYPE_UVEC3:
1164         case VARIABLE_TYPE_VEC3:
1165         {
1166                 result = 3;
1167
1168                 break;
1169         }
1170
1171         case VARIABLE_TYPE_BVEC4:
1172         case VARIABLE_TYPE_DVEC4:
1173         case VARIABLE_TYPE_IVEC4:
1174         case VARIABLE_TYPE_MAT2:
1175         case VARIABLE_TYPE_UVEC4:
1176         case VARIABLE_TYPE_VEC4:
1177         {
1178                 result = 4;
1179
1180                 break;
1181         }
1182
1183         case VARIABLE_TYPE_MAT2X3:
1184         case VARIABLE_TYPE_MAT3X2:
1185         {
1186                 result = 6;
1187
1188                 break;
1189         }
1190
1191         case VARIABLE_TYPE_MAT2X4:
1192         case VARIABLE_TYPE_MAT4X2:
1193         {
1194                 result = 8;
1195
1196                 break;
1197         }
1198
1199         case VARIABLE_TYPE_MAT3:
1200         {
1201                 result = 9;
1202
1203                 break;
1204         }
1205
1206         case VARIABLE_TYPE_MAT3X4:
1207         case VARIABLE_TYPE_MAT4X3:
1208         {
1209                 result = 12;
1210
1211                 break;
1212         }
1213
1214         case VARIABLE_TYPE_MAT4:
1215         {
1216                 result = 16;
1217
1218                 break;
1219         }
1220
1221         default:
1222                 break;
1223         } /* switch (variable_type) */
1224
1225         return result;
1226 }
1227
1228 /** Retrieves a literal defining user-specified shader stage enum.
1229  *
1230  *  @param shader_stage Shader stage to use for the query.
1231  *
1232  *  @return Requested string or "?" if the stage was not recognized.
1233  **/
1234 std::string Utils::getShaderStageString(const _shader_stage& shader_stage)
1235 {
1236         std::string result = "?";
1237
1238         switch (shader_stage)
1239         {
1240         case SHADER_STAGE_FRAGMENT:
1241                 result = "Fragment Shader";
1242                 break;
1243         case SHADER_STAGE_GEOMETRY:
1244                 result = "Geometry Shader";
1245                 break;
1246         case SHADER_STAGE_TESSELLATION_CONTROL:
1247                 result = "Tessellation Control Shader";
1248                 break;
1249         case SHADER_STAGE_TESSELLATION_EVALUATION:
1250                 result = "Tessellation Evaluation Shader";
1251                 break;
1252         case SHADER_STAGE_VERTEX:
1253                 result = "Vertex Shader";
1254                 break;
1255
1256         default:
1257         {
1258                 TCU_FAIL("Unrecognized shader stage");
1259         }
1260         } /* switch (shader_stage) */
1261
1262         return result;
1263 }
1264
1265 /** Retrieves a literal defining user-specified shader stage enum.
1266  *
1267  *  @param shader_stage_glenum Shader stage to use for the query.
1268  *
1269  *  @return Requested string or "?" if the stage was not recognized.
1270  **/
1271 std::string Utils::getShaderStageStringFromGLEnum(const glw::GLenum shader_stage_glenum)
1272 {
1273         std::string result = "?";
1274
1275         switch (shader_stage_glenum)
1276         {
1277         case GL_FRAGMENT_SHADER:
1278                 result = "Fragment Shader";
1279                 break;
1280         case GL_GEOMETRY_SHADER:
1281                 result = "Geometry Shader";
1282                 break;
1283         case GL_TESS_CONTROL_SHADER:
1284                 result = "Tessellation Control Shader";
1285                 break;
1286         case GL_TESS_EVALUATION_SHADER:
1287                 result = "Tessellation Evaluation Shader";
1288                 break;
1289         case GL_VERTEX_SHADER:
1290                 result = "Vertex Shader";
1291                 break;
1292
1293         default:
1294         {
1295                 TCU_FAIL("Unrecognized shader string");
1296         }
1297         } /* switch (shader_stage_glenum) */
1298
1299         return result;
1300 }
1301
1302 /** Returns string that represents program interface name
1303  *
1304  * @param program_interface Program interface
1305  *
1306  * @return String representation of known program interface
1307  **/
1308 const GLchar* Utils::programInterfaceToStr(glw::GLenum program_interface)
1309 {
1310         const GLchar* string = "Unknown program interface";
1311
1312         switch (program_interface)
1313         {
1314         case GL_VERTEX_SUBROUTINE:
1315                 string = "GL_VERTEX_SUBROUTINE";
1316                 break;
1317         case GL_VERTEX_SUBROUTINE_UNIFORM:
1318                 string = "GL_VERTEX_SUBROUTINE_UNIFORM";
1319                 break;
1320         default:
1321                 TCU_FAIL("Not implemented");
1322                 break;
1323         };
1324
1325         return string;
1326 }
1327
1328 /** Returns string that represents pname's name
1329  *
1330  * @param pname pname
1331  *
1332  * @return String representation of known pnames
1333  **/
1334 const GLchar* Utils::pnameToStr(glw::GLenum pname)
1335 {
1336         const GLchar* string = "Unknown pname";
1337
1338         switch (pname)
1339         {
1340         case GL_ACTIVE_SUBROUTINE_UNIFORMS:
1341                 string = "GL_ACTIVE_SUBROUTINE_UNIFORMS";
1342                 break;
1343         case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
1344                 string = "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS";
1345                 break;
1346         case GL_ACTIVE_SUBROUTINES:
1347                 string = "GL_ACTIVE_SUBROUTINES";
1348                 break;
1349         case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
1350                 string = "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH";
1351                 break;
1352         case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
1353                 string = "GL_ACTIVE_SUBROUTINE_MAX_LENGTH";
1354                 break;
1355         case GL_NUM_COMPATIBLE_SUBROUTINES:
1356                 string = "GL_NUM_COMPATIBLE_SUBROUTINES";
1357                 break;
1358         case GL_UNIFORM_SIZE:
1359                 string = "GL_UNIFORM_SIZE";
1360                 break;
1361         case GL_COMPATIBLE_SUBROUTINES:
1362                 string = "GL_COMPATIBLE_SUBROUTINES";
1363                 break;
1364         case GL_UNIFORM_NAME_LENGTH:
1365                 string = "GL_UNIFORM_NAME_LENGTH";
1366                 break;
1367         case GL_ACTIVE_RESOURCES:
1368                 string = "GL_ACTIVE_RESOURCES";
1369                 break;
1370         case GL_MAX_NAME_LENGTH:
1371                 string = "GL_MAX_NAME_LENGTH";
1372                 break;
1373         case GL_MAX_NUM_COMPATIBLE_SUBROUTINES:
1374                 string = "GL_MAX_NUM_COMPATIBLE_SUBROUTINES";
1375                 break;
1376         case GL_NAME_LENGTH:
1377                 string = "GL_NAME_LENGTH";
1378                 break;
1379         case GL_ARRAY_SIZE:
1380                 string = "GL_ARRAY_SIZE";
1381                 break;
1382         case GL_LOCATION:
1383                 string = "GL_LOCATION";
1384                 break;
1385         default:
1386                 TCU_FAIL("Not implemented");
1387                 break;
1388         };
1389
1390         return string;
1391 }
1392
1393 bool Utils::compare(const glw::GLfloat& left, const glw::GLfloat& right)
1394 {
1395         static const glw::GLfloat m_epsilon = 0.00001f;
1396
1397         if (m_epsilon < std::abs(right - left))
1398         {
1399                 return false;
1400         }
1401         else
1402         {
1403                 return true;
1404         }
1405 }
1406
1407 /** Returns a variable type enum corresponding to user-specified base variable type
1408  *  and the number of components it should support.
1409  *
1410  *  @param base_variable_type Base variable type to use for the query.
1411  *  @param n_components       Number of components to consider for the query.
1412  *
1413  *  @return As per description.
1414  **/
1415 Utils::_variable_type Utils::getVariableTypeFromProperties(const _variable_type& base_variable_type,
1416                                                                                                                    const unsigned int&   n_components)
1417 {
1418         _variable_type result = VARIABLE_TYPE_UNKNOWN;
1419
1420         switch (base_variable_type)
1421         {
1422         case VARIABLE_TYPE_BOOL:
1423         {
1424                 switch (n_components)
1425                 {
1426                 case 1:
1427                         result = VARIABLE_TYPE_BOOL;
1428                         break;
1429                 case 2:
1430                         result = VARIABLE_TYPE_BVEC2;
1431                         break;
1432                 case 3:
1433                         result = VARIABLE_TYPE_BVEC3;
1434                         break;
1435                 case 4:
1436                         result = VARIABLE_TYPE_BVEC4;
1437                         break;
1438
1439                 default:
1440                 {
1441                         TCU_FAIL("Unsupported number of components requested");
1442                 }
1443                 } /* switch (n_components) */
1444
1445                 break;
1446         }
1447
1448         case VARIABLE_TYPE_DOUBLE:
1449         {
1450                 switch (n_components)
1451                 {
1452                 case 1:
1453                         result = VARIABLE_TYPE_DOUBLE;
1454                         break;
1455                 case 2:
1456                         result = VARIABLE_TYPE_DVEC2;
1457                         break;
1458                 case 3:
1459                         result = VARIABLE_TYPE_DVEC3;
1460                         break;
1461                 case 4:
1462                         result = VARIABLE_TYPE_DVEC4;
1463                         break;
1464
1465                 default:
1466                 {
1467                         TCU_FAIL("Unsupported number of components requested");
1468                 }
1469                 } /* switch (n_components) */
1470
1471                 break;
1472         }
1473
1474         case VARIABLE_TYPE_FLOAT:
1475         {
1476                 switch (n_components)
1477                 {
1478                 case 1:
1479                         result = VARIABLE_TYPE_FLOAT;
1480                         break;
1481                 case 2:
1482                         result = VARIABLE_TYPE_VEC2;
1483                         break;
1484                 case 3:
1485                         result = VARIABLE_TYPE_VEC3;
1486                         break;
1487                 case 4:
1488                         result = VARIABLE_TYPE_VEC4;
1489                         break;
1490
1491                 default:
1492                 {
1493                         TCU_FAIL("Unsupported number of components requested");
1494                 }
1495                 } /* switch (n_components) */
1496
1497                 break;
1498         }
1499
1500         case VARIABLE_TYPE_INT:
1501         {
1502                 switch (n_components)
1503                 {
1504                 case 1:
1505                         result = VARIABLE_TYPE_INT;
1506                         break;
1507                 case 2:
1508                         result = VARIABLE_TYPE_IVEC2;
1509                         break;
1510                 case 3:
1511                         result = VARIABLE_TYPE_IVEC3;
1512                         break;
1513                 case 4:
1514                         result = VARIABLE_TYPE_IVEC4;
1515                         break;
1516
1517                 default:
1518                 {
1519                         TCU_FAIL("Unsupported number of components requested");
1520                 }
1521                 } /* switch (n_components) */
1522
1523                 break;
1524         }
1525
1526         case VARIABLE_TYPE_UINT:
1527         {
1528                 switch (n_components)
1529                 {
1530                 case 1:
1531                         result = VARIABLE_TYPE_UINT;
1532                         break;
1533                 case 2:
1534                         result = VARIABLE_TYPE_UVEC2;
1535                         break;
1536                 case 3:
1537                         result = VARIABLE_TYPE_UVEC3;
1538                         break;
1539                 case 4:
1540                         result = VARIABLE_TYPE_UVEC4;
1541                         break;
1542
1543                 default:
1544                 {
1545                         TCU_FAIL("Unsupported number of components requested");
1546                 }
1547                 } /* switch (n_components) */
1548
1549                 break;
1550         }
1551
1552         default:
1553         {
1554                 TCU_FAIL("Unrecognized base variable type");
1555         }
1556         } /* switch (base_variable_type) */
1557
1558         return result;
1559 }
1560
1561 /** Returns a GLSL literal corresponding to user-specified variable type.
1562  *
1563  *  @param variable_type Variable type to use for the query.
1564  *
1565  *  @return As per description or [?] if @param variable_type was not
1566  *          recognized.
1567  **/
1568 std::string Utils::getVariableTypeGLSLString(const _variable_type& variable_type)
1569 {
1570         std::string result = "[?]";
1571
1572         switch (variable_type)
1573         {
1574         case VARIABLE_TYPE_BOOL:
1575                 result = "bool";
1576                 break;
1577         case VARIABLE_TYPE_BVEC2:
1578                 result = "bvec2";
1579                 break;
1580         case VARIABLE_TYPE_BVEC3:
1581                 result = "bvec3";
1582                 break;
1583         case VARIABLE_TYPE_BVEC4:
1584                 result = "bvec4";
1585                 break;
1586         case VARIABLE_TYPE_DOUBLE:
1587                 result = "double";
1588                 break;
1589         case VARIABLE_TYPE_DVEC2:
1590                 result = "dvec2";
1591                 break;
1592         case VARIABLE_TYPE_DVEC3:
1593                 result = "dvec3";
1594                 break;
1595         case VARIABLE_TYPE_DVEC4:
1596                 result = "dvec4";
1597                 break;
1598         case VARIABLE_TYPE_FLOAT:
1599                 result = "float";
1600                 break;
1601         case VARIABLE_TYPE_INT:
1602                 result = "int";
1603                 break;
1604         case VARIABLE_TYPE_IVEC2:
1605                 result = "ivec2";
1606                 break;
1607         case VARIABLE_TYPE_IVEC3:
1608                 result = "ivec3";
1609                 break;
1610         case VARIABLE_TYPE_IVEC4:
1611                 result = "ivec4";
1612                 break;
1613         case VARIABLE_TYPE_MAT2:
1614                 result = "mat2";
1615                 break;
1616         case VARIABLE_TYPE_MAT2X3:
1617                 result = "mat2x3";
1618                 break;
1619         case VARIABLE_TYPE_MAT2X4:
1620                 result = "mat2x4";
1621                 break;
1622         case VARIABLE_TYPE_MAT3:
1623                 result = "mat3";
1624                 break;
1625         case VARIABLE_TYPE_MAT3X2:
1626                 result = "mat3x2";
1627                 break;
1628         case VARIABLE_TYPE_MAT3X4:
1629                 result = "mat3x4";
1630                 break;
1631         case VARIABLE_TYPE_MAT4:
1632                 result = "mat4";
1633                 break;
1634         case VARIABLE_TYPE_MAT4X2:
1635                 result = "mat4x2";
1636                 break;
1637         case VARIABLE_TYPE_MAT4X3:
1638                 result = "mat4x3";
1639                 break;
1640         case VARIABLE_TYPE_UINT:
1641                 result = "uint";
1642                 break;
1643         case VARIABLE_TYPE_UVEC2:
1644                 result = "uvec2";
1645                 break;
1646         case VARIABLE_TYPE_UVEC3:
1647                 result = "uvec3";
1648                 break;
1649         case VARIABLE_TYPE_UVEC4:
1650                 result = "uvec4";
1651                 break;
1652         case VARIABLE_TYPE_VEC2:
1653                 result = "vec2";
1654                 break;
1655         case VARIABLE_TYPE_VEC3:
1656                 result = "vec3";
1657                 break;
1658         case VARIABLE_TYPE_VEC4:
1659                 result = "vec4";
1660                 break;
1661
1662         default:
1663         {
1664                 TCU_FAIL("Unrecognized variable type");
1665         }
1666         } /* switch (variable_type) */
1667
1668         return result;
1669 }
1670
1671 /** Constructor.
1672  *
1673  *  @param context Rendering context.
1674  *
1675  **/
1676 APITest1::APITest1(deqp::Context& context)
1677         : TestCase(context, "min_maxes", "Verifies the implementation returns valid GL_MAX_SUBROUTINE* pnames "
1678                                                                          "which meet the minimum maximum requirements enforced by the spec.")
1679         , m_has_test_passed(true)
1680 {
1681         /* Left blank intentionally */
1682 }
1683
1684 /** Executes test iteration.
1685  *
1686  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
1687  */
1688 tcu::TestNode::IterateResult APITest1::iterate()
1689 {
1690         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1691
1692         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
1693         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
1694         {
1695                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
1696         }
1697
1698         /* Iterate over all pnames */
1699         const struct
1700         {
1701                 glw::GLenum pname;
1702                 const char* pname_string;
1703                 glw::GLint  min_value;
1704         } pnames[] = { { GL_MAX_SUBROUTINES, "GL_MAX_SUBROUTINES", 256 },
1705                                    { GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS, "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS", 1024 } };
1706         const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]);
1707
1708         for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname)
1709         {
1710                 glw::GLboolean   bool_value   = GL_FALSE;
1711                 glw::GLdouble     double_value = 0.0;
1712                 glw::GLfloat       float_value  = 0.0f;
1713                 glw::GLint                 int_value    = 0;
1714                 glw::GLint64       int64_value  = 0;
1715                 const glw::GLint   min_value    = pnames[n_pname].min_value;
1716                 const glw::GLenum& pname                = pnames[n_pname].pname;
1717                 const char*                pname_string = pnames[n_pname].pname_string;
1718
1719                 /* Retrieve the pname values */
1720                 gl.getBooleanv(pname, &bool_value);
1721                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() call failed.");
1722
1723                 gl.getDoublev(pname, &double_value);
1724                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetDoublev() call failed.");
1725
1726                 gl.getFloatv(pname, &float_value);
1727                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() call failed.");
1728
1729                 gl.getIntegerv(pname, &int_value);
1730                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed.");
1731
1732                 gl.getInteger64v(pname, &int64_value);
1733                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetInteger64v() call failed.");
1734
1735                 /* Make sure the value reported meets the min max requirement */
1736                 if (int_value < min_value)
1737                 {
1738                         m_testCtx.getLog() << tcu::TestLog::Message << "GL implementation reports a value of [" << int_value
1739                                                            << "]"
1740                                                                   " for property ["
1741                                                            << pname_string << "]"
1742                                                                                                   ", whereas the min max for the property is ["
1743                                                            << min_value << "]." << tcu::TestLog::EndMessage;
1744
1745                         m_has_test_passed = false;
1746                 }
1747
1748                 /* Verify the other getters reported valid values */
1749                 const float epsilon = 1e-5f;
1750
1751                 if (((int_value == 0) && (bool_value == GL_TRUE)) || ((int_value != 0) && (bool_value != GL_TRUE)))
1752                 {
1753                         m_testCtx.getLog() << tcu::TestLog::Message << "Invalid boolean value [" << bool_value
1754                                                            << "]"
1755                                                                   " reported for property ["
1756                                                            << pname_string << "]"
1757                                                                                                   " (int value:["
1758                                                            << int_value << "])" << tcu::TestLog::EndMessage;
1759
1760                         m_has_test_passed = false;
1761                 }
1762
1763                 if (de::abs(double_value - (double)int_value) > epsilon)
1764                 {
1765                         m_testCtx.getLog() << tcu::TestLog::Message << "Invalid double value [" << double_value
1766                                                            << "]"
1767                                                                   " reported for property ["
1768                                                            << pname_string << "]"
1769                                                                                                   " (int value:["
1770                                                            << int_value << "])" << tcu::TestLog::EndMessage;
1771
1772                         m_has_test_passed = false;
1773                 }
1774
1775                 if (de::abs(float_value - (float)int_value) > epsilon)
1776                 {
1777                         m_testCtx.getLog() << tcu::TestLog::Message << "Invalid float value [" << float_value
1778                                                            << "]"
1779                                                                   " reported for property ["
1780                                                            << pname_string << "]"
1781                                                                                                   " (int value:["
1782                                                            << int_value << "])" << tcu::TestLog::EndMessage;
1783
1784                         m_has_test_passed = false;
1785                 }
1786
1787                 if (int64_value != int_value)
1788                 {
1789                         m_testCtx.getLog() << tcu::TestLog::Message << "Invalid 64-bit integer value [" << float_value
1790                                                            << "]"
1791                                                                   " reported for property ["
1792                                                            << pname_string << "]"
1793                                                                                                   " (int value:["
1794                                                            << int_value << "])" << tcu::TestLog::EndMessage;
1795
1796                         m_has_test_passed = false;
1797                 }
1798         } /* for (all pnames) */
1799
1800         if (m_has_test_passed)
1801         {
1802                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1803         }
1804         else
1805         {
1806                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1807         }
1808
1809         return STOP;
1810 }
1811
1812 /** Constructor.
1813  *
1814  *  @param context Rendering context.
1815  *
1816  **/
1817 APITest2::APITest2(deqp::Context& context)
1818         : TestCase(context, "name_getters", "Verifies glGetActiveSubroutineName() and glGetActiveSubroutineUniformName() "
1819                                                                                 "functions work correctly.")
1820         , m_buffer(DE_NULL)
1821         , m_has_test_passed(true)
1822         , m_po_id(0)
1823         , m_subroutine_name1("subroutine1")
1824         , m_subroutine_name2("subroutine2")
1825         , m_subroutine_uniform_name("data_provider")
1826         , m_vs_id(0)
1827 {
1828         /* Left blank intentionally */
1829 }
1830
1831 /** Destroys all ES objects that may have been created during test initialization,
1832  *  as well as releases any buffers that may have been allocated during the process.
1833  */
1834 void APITest2::deinit()
1835 {
1836         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1837
1838         if (m_buffer != DE_NULL)
1839         {
1840                 delete[] m_buffer;
1841
1842                 m_buffer = DE_NULL;
1843         }
1844
1845         if (m_po_id != 0)
1846         {
1847                 gl.deleteProgram(m_po_id);
1848
1849                 m_po_id = 0;
1850         }
1851
1852         if (m_vs_id != 0)
1853         {
1854                 gl.deleteShader(m_vs_id);
1855
1856                 m_vs_id = 0;
1857         }
1858 }
1859
1860 /** Returns body of a vertex shader that should be used for the test.
1861  *
1862  *  @return As per description.
1863  **/
1864 std::string APITest2::getVertexShaderBody()
1865 {
1866         return "#version 400\n"
1867                    "\n"
1868                    "#extension GL_ARB_shader_subroutine : require\n"
1869                    "\n"
1870                    "subroutine int ExampleSubroutineType(int example_argument);\n"
1871                    "\n"
1872                    "subroutine(ExampleSubroutineType) int subroutine1(int example_argument)\n"
1873                    "{\n"
1874                    "    return 1;\n"
1875                    "}\n"
1876                    "\n"
1877                    "subroutine(ExampleSubroutineType) int subroutine2(int example_argument)\n"
1878                    "{\n"
1879                    "    return 2;\n"
1880                    "}\n"
1881                    "\n"
1882                    "subroutine uniform ExampleSubroutineType data_provider;\n"
1883                    "\n"
1884                    "void main()\n"
1885                    "{\n"
1886                    "    gl_Position = vec4(float(data_provider(0)), vec3(1) );\n"
1887                    "}\n";
1888 }
1889
1890 /** Initializes all ES objects required to run the test. */
1891 void APITest2::initTest()
1892 {
1893         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1894
1895         /* Generate program & shader objects */
1896         m_po_id = gl.createProgram();
1897         m_vs_id = gl.createShader(GL_VERTEX_SHADER);
1898
1899         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() or glCreateShader() call(s) failed.");
1900
1901         /* Attach the shader to the program object */
1902         gl.attachShader(m_po_id, m_vs_id);
1903         GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
1904
1905         /* Compile the shader */
1906         glw::GLint  compile_status  = GL_FALSE;
1907         std::string vs_body                     = getVertexShaderBody();
1908         const char* vs_body_raw_ptr = vs_body.c_str();
1909
1910         gl.shaderSource(m_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */);
1911         GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
1912
1913         gl.compileShader(m_vs_id);
1914         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
1915
1916         gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status);
1917         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
1918
1919         if (compile_status != GL_TRUE)
1920         {
1921                 TCU_FAIL("Shader compilation failed.");
1922         }
1923
1924         /* Try to link the program object */
1925         glw::GLint link_status = GL_FALSE;
1926
1927         gl.linkProgram(m_po_id);
1928         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed.");
1929
1930         gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status);
1931         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
1932
1933         if (link_status != GL_TRUE)
1934         {
1935                 TCU_FAIL("Program linking failed.");
1936         }
1937
1938         /* Perform a few sanity checks */
1939         glw::GLint n_active_subroutines                 = 0;
1940         glw::GLint n_active_subroutine_uniforms = 0;
1941
1942         gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines);
1943         gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms);
1944         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call failed.");
1945
1946         if (n_active_subroutines != 2 /* subroutines declared in vertex shader */)
1947         {
1948                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid amount of active subroutines reported; expected: 2,"
1949                                                                                                            " reported:"
1950                                                    << n_active_subroutines << tcu::TestLog::EndMessage;
1951
1952                 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINES property value.");
1953         }
1954
1955         if (n_active_subroutine_uniforms != 1)
1956         {
1957                 m_testCtx.getLog() << tcu::TestLog::Message
1958                                                    << "Invalid amount of active subroutine uniforms reported: expected: 1,"
1959                                                           " reported: "
1960                                                    << n_active_subroutine_uniforms << tcu::TestLog::EndMessage;
1961
1962                 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORMS property value.");
1963         }
1964 }
1965
1966 /** Executes test iteration.
1967  *
1968  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
1969  */
1970 tcu::TestNode::IterateResult APITest2::iterate()
1971 {
1972         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
1973         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
1974         {
1975                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
1976         }
1977
1978         /* Initialize a test program object */
1979         initTest();
1980
1981         /* Verify glGetActiveSubroutineName() works correctly */
1982         verifyGLGetActiveSubroutineNameFunctionality();
1983
1984         /* Verify glGetActiveSubroutineUniformName() works correctly */
1985         verifyGLGetActiveSubroutineUniformNameFunctionality();
1986
1987         /* Done */
1988         if (m_has_test_passed)
1989         {
1990                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1991         }
1992         else
1993         {
1994                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1995         }
1996
1997         return STOP;
1998 }
1999
2000 /** Verifies glGetActiveSubroutineName() behaves as per GL_ARB_shader_subroutine
2001  *  specification.
2002  **/
2003 void APITest2::verifyGLGetActiveSubroutineNameFunctionality()
2004 {
2005         GLsizei                           expected_length1 = (GLsizei)strlen(m_subroutine_name1) + 1;
2006         GLsizei                           expected_length2 = (GLsizei)strlen(m_subroutine_name1) + 1;
2007         const glw::Functions& gl                           = m_context.getRenderContext().getFunctions();
2008         GLsizei                           reported_length  = 0;
2009
2010         gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, /* index */
2011                                                            0,                                                    /* bufsize */
2012                                                            DE_NULL,                                              /* length */
2013                                                            DE_NULL);                                     /* name */
2014         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed.");
2015
2016         gl.getProgramInterfaceiv(m_po_id, GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, &reported_length);
2017         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed.");
2018
2019         if ((reported_length != expected_length1) && (reported_length != expected_length2))
2020         {
2021                 m_testCtx.getLog() << tcu::TestLog::Message
2022                                                    << "Invalid active subroutine name length reported:" << reported_length
2023                                                    << ", instead of: " << expected_length1 << " or " << expected_length2
2024                                                    << tcu::TestLog::EndMessage;
2025
2026                 TCU_FAIL("Incorrect length of active subroutine name");
2027         }
2028
2029         m_buffer = new glw::GLchar[reported_length];
2030
2031         memset(m_buffer, 0, reported_length);
2032
2033         gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, reported_length, DE_NULL, /* length */
2034                                                            m_buffer);
2035         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed.");
2036
2037         if (strcmp(m_buffer, m_subroutine_name1) != 0 && strcmp(m_buffer, m_subroutine_name2) != 0)
2038         {
2039                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine name reported:[" << m_buffer
2040                                                    << "]"
2041                                                           " instead of:["
2042                                                    << m_subroutine_name1 << "]"
2043                                                                                                         " or:["
2044                                                    << m_subroutine_name2 << "]." << tcu::TestLog::EndMessage;
2045
2046                 TCU_FAIL("Invalid active subroutine name reported.");
2047         }
2048
2049         delete[] m_buffer;
2050         m_buffer = DE_NULL;
2051 }
2052
2053 /** Verifies glGetActiveSubroutineUniformName() behaves as per GL_ARB_shader_subroutine
2054  *  specification.
2055  **/
2056 void APITest2::verifyGLGetActiveSubroutineUniformNameFunctionality()
2057 {
2058         GLsizei                           expected_length = (GLsizei)strlen(m_subroutine_uniform_name);
2059         const glw::Functions& gl                          = m_context.getRenderContext().getFunctions();
2060         GLsizei                           reported_length = 0;
2061
2062         gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */
2063                                                                           0,                                                    /* bufsize */
2064                                                                           DE_NULL,                                              /* length */
2065                                                                           DE_NULL);                                             /* name */
2066         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed.");
2067
2068         gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */
2069                                                                           0,                                                    /* bufsize */
2070                                                                           &reported_length, DE_NULL);   /* name */
2071         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed.");
2072
2073         // reported_length is the actual number of characters written into <name>
2074         // If <bufSize> is 0, reported_length should be 0
2075         if (reported_length != 0)
2076         {
2077                 m_testCtx.getLog() << tcu::TestLog::Message
2078                                                    << "Invalid active subroutine uniform name length reported:" << reported_length
2079                                                    << ", instead of: " << 0 << tcu::TestLog::EndMessage;
2080
2081                 TCU_FAIL("Incorrect length of active subroutine uniform name");
2082         }
2083
2084         m_buffer = new glw::GLchar[expected_length + 1];
2085
2086         memset(m_buffer, 0, expected_length + 1);
2087
2088         gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, expected_length + 1, &reported_length, m_buffer);
2089         GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformName() call failed.");
2090
2091         if (reported_length != expected_length)
2092         {
2093                 m_testCtx.getLog() << tcu::TestLog::Message
2094                                                    << "Invalid active subroutine uniform name length reported:" << reported_length
2095                                                    << ", instead of: " << expected_length << tcu::TestLog::EndMessage;
2096
2097                 TCU_FAIL("Incorrect length of active subroutine uniform name");
2098         }
2099
2100         if (strcmp(m_buffer, m_subroutine_uniform_name) != 0)
2101         {
2102                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine uniform name reported:[" << m_buffer
2103                                                    << "]"
2104                                                           " instead of:["
2105                                                    << m_subroutine_uniform_name << "]" << tcu::TestLog::EndMessage;
2106
2107                 TCU_FAIL("Invalid active subroutine uniform name reported.");
2108         }
2109
2110         delete[] m_buffer;
2111         m_buffer = DE_NULL;
2112 }
2113
2114 /** Constructor.
2115  *
2116  *  @param context Rendering context.
2117  *
2118  **/
2119 FunctionalTest1_2::FunctionalTest1_2(deqp::Context& context)
2120         : TestCase(context, "two_subroutines_single_subroutine_uniform",
2121                            "Verifies the subroutines work correctly in a vertex shader for"
2122                            " bool/float/int/uint/double/*vec*/*mat* argument and return types")
2123         , m_has_test_passed(true)
2124         , m_po_id(0)
2125         , m_po_getter0_subroutine_index(GL_INVALID_INDEX)
2126         , m_po_getter1_subroutine_index(GL_INVALID_INDEX)
2127         , m_po_subroutine_uniform_index(-1)
2128         , m_xfb_bo_id(0)
2129         , m_vao_id(0)
2130         , m_vs_id(0)
2131 {
2132         /* Left blank intentionally */
2133 }
2134
2135 /** Destroys all ES objects that may have been created during test initialization,
2136  *  as well as releases any buffers that may have been allocated during the process.
2137  */
2138 void FunctionalTest1_2::deinit()
2139 {
2140         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2141
2142         deinitTestIteration();
2143
2144         if (m_xfb_bo_id != 0)
2145         {
2146                 gl.deleteBuffers(1, &m_xfb_bo_id);
2147
2148                 m_xfb_bo_id = 0;
2149         }
2150
2151         if (m_vao_id != 0)
2152         {
2153                 gl.deleteVertexArrays(1, &m_vao_id);
2154
2155                 m_vao_id = 0;
2156         }
2157 }
2158
2159 /** Deinitializes GL objects that are iteration-specific */
2160 void FunctionalTest1_2::deinitTestIteration()
2161 {
2162         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2163
2164         if (m_po_id != 0)
2165         {
2166                 gl.deleteProgram(m_po_id);
2167
2168                 m_po_id = 0;
2169         }
2170
2171         if (m_vs_id != 0)
2172         {
2173                 gl.deleteShader(m_vs_id);
2174
2175                 m_vs_id = 0;
2176         }
2177 }
2178
2179 /** Executes a single test iteration using user-specified test case propertiesz.
2180  *
2181  *  @param test-case Test case descriptor.
2182  *
2183  *  @return true if the test iteration passed, false otherwise.
2184  **/
2185 bool FunctionalTest1_2::executeTestIteration(const _test_case& test_case)
2186 {
2187         const glw::Functions& gl         = m_context.getRenderContext().getFunctions();
2188         bool                              result = true;
2189
2190         /* Build the test program */
2191         std::string                empty_body;
2192         std::string                vs_body                = getVertexShaderBody(test_case.variable_type, test_case.array_size);
2193         const glw::GLchar* xfb_varyings[] = { "result" };
2194         const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]);
2195
2196         if (!Utils::buildProgram(gl, vs_body, empty_body, empty_body, empty_body, empty_body, xfb_varyings, n_xfb_varyings,
2197                                                          &m_vs_id, NULL, /* out_tc_id */
2198                                                          NULL,                   /* out_te_id */
2199                                                          NULL,                   /* out_gs_id */
2200                                                          NULL, &m_po_id))
2201         {
2202                 TCU_FAIL("Test program failed to build.");
2203         }
2204
2205         /* Retrieve subroutine locations */
2206         m_po_getter0_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter0");
2207         m_po_getter1_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter1");
2208
2209         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed.");
2210
2211         if (m_po_getter0_subroutine_index == GL_INVALID_INDEX || m_po_getter1_subroutine_index == GL_INVALID_INDEX)
2212         {
2213                 TCU_FAIL("At least one subroutine is considered inactive which is invalid.");
2214         }
2215
2216         /* Retrieve subroutine uniform location */
2217         m_po_subroutine_uniform_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "colorGetterUniform");
2218
2219         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call failed.");
2220
2221         if (m_po_subroutine_uniform_index == -1)
2222         {
2223                 TCU_FAIL("Subroutine uniform is considered inactive which is invalid.");
2224         }
2225
2226         /* Set up XFB BO storage */
2227         const Utils::_variable_type base_variable_type  = Utils::getBaseVariableType(test_case.variable_type);
2228         unsigned int                            iteration_xfb_bo_size = Utils::getComponentSizeForVariableType(base_variable_type) *
2229                                                                                  Utils::getNumberOfComponentsForVariableType(test_case.variable_type);
2230         unsigned int total_xfb_bo_size = 0;
2231
2232         if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2233         {
2234                 /* Boolean varyings are not supported by OpenGL. Instead, we use ints to output
2235                  * boolean values. */
2236                 iteration_xfb_bo_size = static_cast<unsigned int>(iteration_xfb_bo_size * sizeof(int));
2237         }
2238
2239         total_xfb_bo_size = iteration_xfb_bo_size * 2 /* subroutines we will be testing */;
2240
2241         gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, total_xfb_bo_size, DE_NULL /* data */, GL_STATIC_DRAW);
2242         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");
2243
2244         /* Activate test program object */
2245         gl.useProgram(m_po_id);
2246         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
2247
2248         /* Run two iterations. Each iteration should invoke different subroutine. */
2249         const glw::GLuint  subroutine_indices[] = { m_po_getter0_subroutine_index, m_po_getter1_subroutine_index };
2250         const unsigned int n_subroutine_indices = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]);
2251
2252         for (unsigned int n_subroutine_index = 0; n_subroutine_index < n_subroutine_indices; ++n_subroutine_index)
2253         {
2254                 /* Configure which subroutine should be used for the draw call */
2255                 glw::GLuint current_subroutine_index = subroutine_indices[n_subroutine_index];
2256
2257                 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 1 /* count */, &current_subroutine_index);
2258                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed.");
2259
2260                 /* Update XFB binding so that we do not overwrite data XFBed in previous iterations */
2261                 gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */
2262                                                    m_xfb_bo_id, iteration_xfb_bo_size * n_subroutine_index, iteration_xfb_bo_size);
2263                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange() call failed.");
2264
2265                 /* Draw a single point */
2266                 gl.beginTransformFeedback(GL_POINTS);
2267                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");
2268                 {
2269                         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
2270                         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
2271                 }
2272                 gl.endTransformFeedback();
2273                 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");
2274         } /* for (all subroutine indices) */
2275
2276         /* Map the BO storage into process space */
2277         const void* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
2278         GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed.");
2279
2280         result &= verifyXFBData(xfb_data_ptr, test_case.variable_type);
2281
2282         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
2283         GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffeR() call failed.");
2284
2285         return result;
2286 }
2287
2288 /** Retrieves body of a vertex shader that should be used to verify
2289  *  subroutine support, given user-specified test iteration properties.
2290  *
2291  *  @param variable_type GLSL type that should be used for argument and
2292  *                       return type definition in a subroutine. This setting
2293  *                       also affects type of the only output variable in the shader.
2294  *  @param array_size    1 if non-arrayed arguments/return types should be tested;
2295  *                       2 if arrayed arguments/return types should be tested.
2296  *
2297  *  @return Requested string.
2298  **/
2299 std::string FunctionalTest1_2::getVertexShaderBody(const Utils::_variable_type& variable_type, unsigned int array_size)
2300 {
2301         Utils::_variable_type base_variable_type                 = Utils::getBaseVariableType(variable_type);
2302         unsigned int              n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type);
2303         std::stringstream        result_sstream;
2304         std::string                       variable_type_glsl = Utils::getVariableTypeGLSLString(variable_type);
2305         std::stringstream        variable_type_glsl_array_sstream;
2306         std::stringstream        variable_type_glsl_arrayed_sstream;
2307
2308         variable_type_glsl_arrayed_sstream << variable_type_glsl;
2309
2310         if (array_size > 1)
2311         {
2312                 variable_type_glsl_array_sstream << "[" << array_size << "]";
2313                 variable_type_glsl_arrayed_sstream << variable_type_glsl_array_sstream.str();
2314         }
2315
2316         /* Form pre-amble */
2317         result_sstream << "#version 400\n"
2318                                           "\n"
2319                                           "#extension GL_ARB_shader_subroutine : require\n";
2320
2321         if (variable_type == Utils::VARIABLE_TYPE_DOUBLE)
2322         {
2323                 result_sstream << "#extension GL_ARB_gpu_shader_fp64 : require\n";
2324         }
2325
2326         /* Form subroutine type declaration */
2327         result_sstream << "\n"
2328                                           "subroutine "
2329                                    << variable_type_glsl_arrayed_sstream.str() << " colorGetter(in " << variable_type_glsl
2330                                    << " in_value" << variable_type_glsl_array_sstream.str() << ");\n"
2331                                                                                                                                                            "\n";
2332
2333         /* Declare getter functions */
2334         for (int n_getter = 0; n_getter < 2; ++n_getter)
2335         {
2336                 result_sstream << "subroutine(colorGetter) " << variable_type_glsl_arrayed_sstream.str() << " getter"
2337                                            << n_getter << "(in " << variable_type_glsl << " in_value"
2338                                            << variable_type_glsl_array_sstream.str() << ")\n"
2339                                                                                                                                         "{\n";
2340
2341                 if (array_size > 1)
2342                 {
2343                         result_sstream << variable_type_glsl << " temp" << variable_type_glsl_array_sstream.str() << ";\n";
2344                 }
2345
2346                 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2347                 {
2348                         if (array_size > 1)
2349                         {
2350                                 for (unsigned int array_index = 0; array_index < array_size; ++array_index)
2351                                 {
2352                                         result_sstream << "    temp[" << array_index << "]"
2353                                                                                                                                         " = "
2354                                                                    << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "")
2355                                                                    << "(in_value[" << array_index << "]);\n";
2356                                 }
2357
2358                                 result_sstream << "    return temp;\n";
2359                         }
2360                         else
2361                         {
2362                                 result_sstream << "    return "
2363                                                            << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "")
2364                                                            << "(in_value);\n";
2365                         }
2366                 } /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */
2367                 else
2368                 {
2369                         if (array_size > 1)
2370                         {
2371                                 for (unsigned int array_index = 0; array_index < array_size; ++array_index)
2372                                 {
2373                                         result_sstream << "    temp[" << array_index << "]"
2374                                                                                                                                         " = in_value["
2375                                                                    << array_index << "] + " << (n_getter + 1) << ";\n";
2376                                 }
2377
2378                                 result_sstream << "    return temp;\n";
2379                         }
2380                         else
2381                         {
2382                                 result_sstream << "    return (in_value + " << (n_getter + 1) << ");\n";
2383                         }
2384                 }
2385
2386                 result_sstream << "}\n";
2387         } /* for (both getter functions) */
2388
2389         /* Declare subroutine uniform */
2390         result_sstream << "subroutine uniform colorGetter colorGetterUniform;\n"
2391                                           "\n";
2392
2393         /* Declare output variable */
2394         result_sstream << "out ";
2395
2396         if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2397         {
2398                 Utils::_variable_type result_as_int_variable_type =
2399                         Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components);
2400                 std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type);
2401
2402                 result_sstream << variable_type_glsl_as_int;
2403         }
2404         else
2405         {
2406                 result_sstream << variable_type_glsl;
2407         }
2408
2409         result_sstream << " result;\n"
2410                                           "\n";
2411
2412         /* Declare main(): prepare input argument for the subroutine function */
2413         result_sstream << "void main()\n"
2414                                           "{\n"
2415                                           "    "
2416                                    << variable_type_glsl << " temp";
2417
2418         if (array_size > 1)
2419         {
2420                 result_sstream << "[" << array_size << "]";
2421         };
2422
2423         result_sstream << ";\n";
2424
2425         for (unsigned int array_index = 0; array_index < array_size; ++array_index)
2426         {
2427                 result_sstream << "    temp";
2428
2429                 if (array_size > 1)
2430                 {
2431                         result_sstream << "[" << array_index << "]";
2432                 }
2433
2434                 result_sstream << " = " << variable_type_glsl << "(";
2435
2436                 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2437                 {
2438                         result_sstream << "true";
2439                 }
2440                 else
2441                 {
2442                         for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component)
2443                         {
2444                                 result_sstream << "3";
2445
2446                                 if (n_component != (n_variable_type_components - 1))
2447                                 {
2448                                         result_sstream << ", ";
2449                                 }
2450                         } /* for (all components) */
2451                 }
2452
2453                 result_sstream << ");\n";
2454         } /* for (all array indices) */
2455
2456         /* Declare main(): call the subroutine. Verify the input and write the result
2457          *                 to the output variable.
2458          **/
2459         if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2460         {
2461                 Utils::_variable_type result_as_int_variable_type =
2462                         Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components);
2463                 std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type);
2464
2465                 result_sstream << variable_type_glsl_arrayed_sstream.str() << " subroutine_result = colorGetterUniform(temp);\n"
2466                                                                                                                                           "result = ";
2467
2468                 for (unsigned int array_index = 0; array_index < array_size; ++array_index)
2469                 {
2470                         if (variable_type_glsl == "bool")
2471                                 result_sstream << "bool(subroutine_result";
2472                         else
2473                                 result_sstream << "all(subroutine_result";
2474
2475                         if (array_size > 1)
2476                         {
2477                                 result_sstream << "[" << array_index << "]";
2478                         }
2479
2480                         result_sstream << ")";
2481
2482                         if (array_index != (array_size - 1))
2483                         {
2484                                 result_sstream << "&& ";
2485                         }
2486                 }
2487
2488                 result_sstream << " == true ? " << variable_type_glsl_as_int << "(1) : " << variable_type_glsl_as_int << "(0);";
2489         }
2490         else
2491         {
2492                 if (array_size > 1)
2493                 {
2494                         DE_ASSERT(array_size == 2);
2495
2496                         result_sstream << variable_type_glsl << " subroutine_result" << variable_type_glsl_array_sstream.str()
2497                                                    << " = colorGetterUniform(temp);\n"
2498                                                           "\n"
2499                                                           "if (subroutine_result[0] == subroutine_result[1]) result = subroutine_result[0];\n"
2500                                                           "else\n"
2501                                                           "result = "
2502                                                    << variable_type_glsl << "(-1);\n";
2503                 }
2504                 else
2505                 {
2506                         result_sstream << "result = colorGetterUniform(temp);\n";
2507                 }
2508         }
2509
2510         /* All done */
2511         result_sstream << "}\n";
2512
2513         return result_sstream.str();
2514 }
2515
2516 /** Initializes all GL objects required to run the test. */
2517 void FunctionalTest1_2::initTest()
2518 {
2519         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2520
2521         /* Generate buffer object to hold result XFB data */
2522         gl.genBuffers(1, &m_xfb_bo_id);
2523         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");
2524
2525         /* Set up XFB BO bindings */
2526         gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id);
2527         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");
2528
2529         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id);
2530         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");
2531
2532         /* Generate VAO to use for the draw calls */
2533         gl.genVertexArrays(1, &m_vao_id);
2534         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
2535
2536         gl.bindVertexArray(m_vao_id);
2537         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
2538 }
2539
2540 /** Executes test iteration.
2541  *
2542  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
2543  */
2544 tcu::TestNode::IterateResult FunctionalTest1_2::iterate()
2545 {
2546         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
2547         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
2548         {
2549                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
2550         }
2551
2552         /* Initialize a test program object */
2553         initTest();
2554
2555         /* Construct test case descriptors: first, iIerate over all
2556          * variable types we want to cover */
2557         const Utils::_variable_type variable_types[] = {
2558                 Utils::VARIABLE_TYPE_BOOL,   Utils::VARIABLE_TYPE_BVEC2,  Utils::VARIABLE_TYPE_BVEC3,
2559                 Utils::VARIABLE_TYPE_BVEC4,  Utils::VARIABLE_TYPE_DOUBLE, Utils::VARIABLE_TYPE_FLOAT,
2560                 Utils::VARIABLE_TYPE_INT,       Utils::VARIABLE_TYPE_IVEC2,  Utils::VARIABLE_TYPE_IVEC3,
2561                 Utils::VARIABLE_TYPE_IVEC4,  Utils::VARIABLE_TYPE_MAT2,   Utils::VARIABLE_TYPE_MAT2X3,
2562                 Utils::VARIABLE_TYPE_MAT2X4, Utils::VARIABLE_TYPE_MAT3,   Utils::VARIABLE_TYPE_MAT3X2,
2563                 Utils::VARIABLE_TYPE_MAT3X4, Utils::VARIABLE_TYPE_MAT4,   Utils::VARIABLE_TYPE_MAT4X2,
2564                 Utils::VARIABLE_TYPE_MAT4X3, Utils::VARIABLE_TYPE_UINT,   Utils::VARIABLE_TYPE_UVEC2,
2565                 Utils::VARIABLE_TYPE_UVEC3,  Utils::VARIABLE_TYPE_UVEC4,  Utils::VARIABLE_TYPE_VEC2,
2566                 Utils::VARIABLE_TYPE_VEC3,   Utils::VARIABLE_TYPE_VEC4
2567         };
2568         const unsigned int n_variable_types = sizeof(variable_types) / sizeof(variable_types[0]);
2569
2570         for (unsigned int n_variable_type = 0; n_variable_type < n_variable_types; ++n_variable_type)
2571         {
2572                 Utils::_variable_type current_variable_type = variable_types[n_variable_type];
2573
2574                 /* We need to test both arrayed and non-arrayed arguments */
2575                 for (unsigned int array_size = 1; array_size < 3; ++array_size)
2576                 {
2577                         /* Exclude double variables if the relevant extension is unavailable */
2578                         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_gpu_shader_fp64") &&
2579                                 current_variable_type == Utils::VARIABLE_TYPE_DOUBLE)
2580                         {
2581                                 continue;
2582                         }
2583
2584                         /* Form the descriptor */
2585                         _test_case test_case;
2586
2587                         test_case.array_size    = array_size;
2588                         test_case.variable_type = current_variable_type;
2589
2590                         /* Store the test case descriptor */
2591                         m_test_cases.push_back(test_case);
2592                 } /* for (both arrayed and non-arrayed arguments) */
2593         }        /* for (all variable types) */
2594
2595         /* Iterate over all test cases and execute the test */
2596         for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end();
2597                  ++test_case_iterator)
2598         {
2599                 const _test_case& test_case = *test_case_iterator;
2600
2601                 m_has_test_passed &= executeTestIteration(test_case);
2602
2603                 /* Release GL objects that were created during the execution */
2604                 deinitTestIteration();
2605         } /* for (all test cases) */
2606
2607         /* Done */
2608         if (m_has_test_passed)
2609         {
2610                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2611         }
2612         else
2613         {
2614                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2615         }
2616
2617         return STOP;
2618 }
2619
2620 /** Verifies data that has been XFBed out by the vertex shader.
2621  *
2622  *  @param xfb_data      Buffer holding the data.
2623  *  @param variable_type GLSL type used for the test iteration
2624  *                       that generated the data at @param xfb_data.
2625  *
2626  *  @return true if the data was found to be valid, false if it
2627  *               was detected to be incorrect.
2628  **/
2629 bool FunctionalTest1_2::verifyXFBData(const void* xfb_data, const Utils::_variable_type& variable_type)
2630 {
2631         const Utils::_variable_type base_variable_type             = Utils::getBaseVariableType(variable_type);
2632         const float                                     epsilon                                    = 1e-5f;
2633         const unsigned int                      n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type);
2634         bool                                            result                                     = true;
2635         const unsigned char*            traveller_ptr                      = (const unsigned char*)xfb_data;
2636
2637         /* Boolean arguments/return types are tested with a slightly different shader so we
2638          * need to test them in a separate code-path.
2639          */
2640         if (base_variable_type == Utils::VARIABLE_TYPE_BOOL)
2641         {
2642                 /* 0 should be returned when getter0 is used, 1 otherwise */
2643                 const unsigned int ref_values[] = { 0, 1 };
2644                 const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]);
2645
2646                 for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value)
2647                 {
2648                         const unsigned int ref_value = ref_values[n_ref_value];
2649
2650                         for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component)
2651                         {
2652                                 int* result_value_ptr = (int*)(traveller_ptr);
2653
2654                                 if (*result_value_ptr != (int)ref_value)
2655                                 {
2656                                         m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using "
2657                                                                                                                                    "["
2658                                                                            << Utils::getVariableTypeGLSLString(variable_type) << "]"
2659                                                                            << " argument/return types ("
2660                                                                                   "expected:["
2661                                                                            << ref_value << "], found:[" << *result_value_ptr << "])"
2662                                                                            << tcu::TestLog::EndMessage;
2663
2664                                         result = false;
2665                                         break;
2666                                 }
2667
2668                                 traveller_ptr += sizeof(int);
2669                         } /* for (all components) */
2670                 }        /* for (all reference values) */
2671         }                 /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */
2672         else
2673         {
2674                 /* 4 should be returned when getter0 is used, 5 otherwise */
2675                 const unsigned int ref_values[] = { 4, 5 };
2676                 const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]);
2677
2678                 for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value)
2679                 {
2680                         const unsigned int ref_value = ref_values[n_ref_value];
2681
2682                         DE_ASSERT(
2683                                 base_variable_type == Utils::VARIABLE_TYPE_DOUBLE || base_variable_type == Utils::VARIABLE_TYPE_FLOAT ||
2684                                 base_variable_type == Utils::VARIABLE_TYPE_INT || base_variable_type == Utils::VARIABLE_TYPE_UINT);
2685
2686                         for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component)
2687                         {
2688                                 const double* double_value_ptr = (double*)traveller_ptr;
2689                                 const float*  float_value_ptr  = (float*)traveller_ptr;
2690                                 const int*      int_value_ptr   = (int*)traveller_ptr;
2691
2692                                 switch (base_variable_type)
2693                                 {
2694                                 case Utils::VARIABLE_TYPE_DOUBLE:
2695                                 {
2696                                         if (de::abs(*double_value_ptr - (double)ref_value) > epsilon)
2697                                         {
2698                                                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using "
2699                                                                                                                                            "["
2700                                                                                    << Utils::getVariableTypeGLSLString(variable_type) << "]"
2701                                                                                    << " argument/return types ("
2702                                                                                           "expected:["
2703                                                                                    << ref_value << "], found:[" << *double_value_ptr << "])"
2704                                                                                    << tcu::TestLog::EndMessage;
2705
2706                                                 result = false;
2707                                         }
2708
2709                                         traveller_ptr += sizeof(double);
2710                                         break;
2711                                 }
2712
2713                                 case Utils::VARIABLE_TYPE_FLOAT:
2714                                 {
2715                                         if (de::abs(*float_value_ptr - (float)ref_value) > epsilon)
2716                                         {
2717                                                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using "
2718                                                                                                                                            "["
2719                                                                                    << Utils::getVariableTypeGLSLString(variable_type) << "]"
2720                                                                                    << " argument/return types ("
2721                                                                                           "expected:["
2722                                                                                    << ref_value << "], found:[" << *float_value_ptr << "])"
2723                                                                                    << tcu::TestLog::EndMessage;
2724
2725                                                 result = false;
2726                                         }
2727
2728                                         traveller_ptr += sizeof(float);
2729                                         break;
2730                                 }
2731
2732                                 case Utils::VARIABLE_TYPE_INT:
2733                                 case Utils::VARIABLE_TYPE_UINT:
2734                                 {
2735                                         if (*int_value_ptr != (int)ref_value)
2736                                         {
2737                                                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using "
2738                                                                                                                                            "["
2739                                                                                    << Utils::getVariableTypeGLSLString(variable_type) << "]"
2740                                                                                    << " argument/return types ("
2741                                                                                           "expected:["
2742                                                                                    << ref_value << "], found:[" << *int_value_ptr << "])"
2743                                                                                    << tcu::TestLog::EndMessage;
2744
2745                                                 result = false;
2746                                         }
2747
2748                                         traveller_ptr += sizeof(int);
2749                                         break;
2750                                 }
2751
2752                                 default:
2753                                         break;
2754                                 } /* switch (base_variable_type) */
2755                         }        /* for (all components) */
2756                 }                 /* for (all reference values) */
2757         }
2758
2759         return result;
2760 }
2761
2762 /** Constructor
2763  *
2764  * @param context CTS context
2765  **/
2766 FunctionalTest3_4::FunctionalTest3_4(deqp::Context& context)
2767         : TestCase(context, "four_subroutines_with_two_uniforms", "Verify Get* API and draw calls")
2768         , m_n_active_subroutine_uniforms(0)
2769         , m_n_active_subroutine_uniform_locations(0)
2770         , m_n_active_subroutines(0)
2771         , m_n_active_subroutine_uniform_name_length(0)
2772         , m_n_active_subroutine_name_length(0)
2773         , m_n_active_subroutine_uniform_size(0)
2774 {
2775         /* Nothing to be done here */
2776 }
2777
2778 /** Execute test
2779  *
2780  * @return tcu::TestNode::STOP
2781  **/
2782 tcu::TestNode::IterateResult FunctionalTest3_4::iterate()
2783 {
2784         static const glw::GLchar* vertex_shader_code =
2785                 "#version 400 core\n"
2786                 "#extension GL_ARB_shader_subroutine : require\n"
2787                 "\n"
2788                 "precision highp float;\n"
2789                 "\n"
2790                 "// Sub routine type declaration\n"
2791                 "subroutine vec4 routine_type(in vec4 iparam);\n"
2792                 "\n"
2793                 "// Sub routine definitions\n"
2794                 "subroutine(routine_type) vec4 inverse_order(in vec4 iparam)\n"
2795                 "{\n"
2796                 "    return iparam.wzyx;\n"
2797                 "}\n"
2798                 "\n"
2799                 "subroutine(routine_type) vec4 negate(in vec4 iparam)\n"
2800                 "{\n"
2801                 "    return -iparam;\n"
2802                 "}\n"
2803                 "\n"
2804                 "subroutine(routine_type) vec4 inverse(in vec4 iparam)\n"
2805                 "{\n"
2806                 "    return 1 / iparam;\n"
2807                 "}\n"
2808                 "\n"
2809                 "subroutine(routine_type) vec4 square(in vec4 iparam)\n"
2810                 "{\n"
2811                 "    return iparam * iparam;\n"
2812                 "}\n"
2813                 "\n"
2814                 "// Sub routine uniforms\n"
2815                 "subroutine uniform routine_type first_routine;\n"
2816                 "subroutine uniform routine_type second_routine;\n"
2817                 "\n"
2818                 "// Input data\n"
2819                 "uniform vec4 input_data;\n"
2820                 "\n"
2821                 "// Output\n"
2822                 "out vec4 out_input_data;\n"
2823                 "out vec4 out_result_from_first_routine;\n"
2824                 "out vec4 out_result_from_second_routine;\n"
2825                 "out vec4 out_result_from_combined_routines;\n"
2826                 "out vec4 out_result_from_routines_combined_in_reveresed_order;\n"
2827                 "\n"
2828                 "void main()\n"
2829                 "{\n"
2830                 "    out_input_data                                       = input_data;\n"
2831                 "    out_result_from_first_routine                        = first_routine(input_data);\n"
2832                 "    out_result_from_second_routine                       = second_routine(input_data);\n"
2833                 "    out_result_from_combined_routines                    = second_routine(first_routine(input_data));\n"
2834                 "    out_result_from_routines_combined_in_reveresed_order = first_routine(second_routine(input_data));\n"
2835                 "}\n"
2836                 "\n";
2837
2838         static const GLchar* varying_names[] = {
2839                 "out_input_data",
2840                 "out_result_from_first_routine",
2841                 "out_result_from_second_routine",
2842                 "out_result_from_combined_routines",
2843                 "out_result_from_routines_combined_in_reveresed_order",
2844         };
2845
2846         static const GLchar* subroutine_uniform_names[] = { "first_routine", "second_routine" };
2847
2848         static const GLchar* subroutine_names[] = { "inverse_order", "negate", "inverse", "square" };
2849
2850         static const GLuint n_varyings                                     = sizeof(varying_names) / sizeof(varying_names[0]);
2851         static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */;
2852
2853         static const GLuint inverse_order_routine_index = 0;
2854         static const GLuint negate_routine_index                = 1;
2855         static const GLuint inverse_routine_index               = 2;
2856         static const GLuint square_routine_index                = 3;
2857
2858         /* Test data */
2859         static const Utils::vec4<GLfloat> inverse_order_negate_data[5] = {
2860                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f),
2861                 Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f),
2862                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f),
2863         };
2864
2865         static const Utils::vec4<GLfloat> inverse_order_inverse_data[5] = {
2866                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f),
2867                 Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f),
2868                 Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f),
2869         };
2870
2871         static const Utils::vec4<GLfloat> inverse_order_square_data[5] = {
2872                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f),
2873                 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),   Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),
2874                 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),
2875         };
2876
2877         static const Utils::vec4<GLfloat> negate_inverse_data[5] = {
2878                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f),
2879                 Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f),
2880                 Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f),
2881         };
2882
2883         static const Utils::vec4<GLfloat> negate_square_data[5] = {
2884                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f),   Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f),
2885                 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),    Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),
2886                 Utils::vec4<GLfloat>(-4.0f, -1.0f, -1.0f, -4.0f),
2887         };
2888
2889         static const Utils::vec4<GLfloat> inverse_square_data[5] = {
2890                 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f),
2891                 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f),   Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f),
2892                 Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f),
2893         };
2894
2895         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
2896         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
2897         {
2898                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
2899         }
2900
2901         m_n_active_subroutine_uniforms                    = 2;
2902         m_n_active_subroutine_uniform_locations   = 2;
2903         m_n_active_subroutines                                    = 4;
2904         m_n_active_subroutine_uniform_name_length = 0;
2905         m_n_active_subroutine_name_length                 = 0;
2906         m_n_active_subroutine_uniform_size                = 1;
2907
2908         /* GL objects */
2909         Utils::program   program(m_context);
2910         Utils::buffer     transform_feedback_buffer(m_context);
2911         Utils::vertexArray vao(m_context);
2912
2913         bool result = true;
2914
2915         /* Calculate max name lengths for subroutines and subroutine uniforms */
2916         for (GLint i = 0; i < m_n_active_subroutine_uniforms; ++i)
2917         {
2918                 const GLsizei length = (GLsizei)strlen(subroutine_uniform_names[i]);
2919
2920                 if (length > m_n_active_subroutine_uniform_name_length)
2921                 {
2922                         m_n_active_subroutine_uniform_name_length = length;
2923                 }
2924         }
2925
2926         for (GLint i = 0; i < m_n_active_subroutines; ++i)
2927         {
2928                 const GLsizei length = (GLsizei)strlen(subroutine_names[i]);
2929
2930                 if (length > m_n_active_subroutine_name_length)
2931                 {
2932                         m_n_active_subroutine_name_length = length;
2933                 }
2934         }
2935
2936         /* Init */
2937         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names,
2938                                   n_varyings);
2939
2940         vao.generate();
2941         vao.bind();
2942
2943         transform_feedback_buffer.generate();
2944         transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
2945                                                                          GL_DYNAMIC_COPY);
2946         transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
2947
2948         program.use();
2949
2950         /* Inspect Get* API */
2951         if ((false == inspectProgramStageiv(program.m_program_object_id)) ||
2952                 (false == inspectActiveSubroutineUniformiv(program.m_program_object_id, subroutine_uniform_names)) ||
2953                 (false == inspectActiveSubroutineUniformName(program.m_program_object_id, subroutine_uniform_names)) ||
2954                 (false == inspectActiveSubroutineName(program.m_program_object_id, subroutine_names)) ||
2955                 (false ==
2956                  inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, false)))
2957         {
2958                 result = false;
2959         }
2960
2961         /* Inspect GetProgram* API */
2962         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query"))
2963         {
2964                 if ((false == inspectProgramInterfaceiv(program.m_program_object_id)) ||
2965                         (false ==
2966                          inspectProgramResourceiv(program.m_program_object_id, subroutine_names, subroutine_uniform_names)) ||
2967                         (false ==
2968                          inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, true)))
2969                 {
2970                         result = false;
2971                 }
2972         }
2973
2974         /* Test shader execution */
2975         if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
2976                                                    subroutine_names[negate_routine_index], subroutine_uniform_names, inverse_order_negate_data,
2977                                                    false)) ||
2978                 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
2979                                                    subroutine_names[inverse_routine_index], subroutine_uniform_names,
2980                                                    inverse_order_inverse_data, false)) ||
2981                 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
2982                                                    subroutine_names[square_routine_index], subroutine_uniform_names, inverse_order_square_data,
2983                                                    false)) ||
2984                 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index],
2985                                                    subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data,
2986                                                    false)) ||
2987                 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index],
2988                                                    subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data,
2989                                                    false)) ||
2990                 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index],
2991                                                    subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data,
2992                                                    false)))
2993         {
2994                 result = false;
2995         }
2996
2997         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query"))
2998         {
2999                 if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
3000                                                            subroutine_names[negate_routine_index], subroutine_uniform_names,
3001                                                            inverse_order_negate_data, true)) ||
3002                         (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
3003                                                            subroutine_names[inverse_routine_index], subroutine_uniform_names,
3004                                                            inverse_order_inverse_data, true)) ||
3005                         (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index],
3006                                                            subroutine_names[square_routine_index], subroutine_uniform_names,
3007                                                            inverse_order_square_data, true)) ||
3008                         (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index],
3009                                                            subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data,
3010                                                            true)) ||
3011                         (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index],
3012                                                            subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data,
3013                                                            true)) ||
3014                         (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index],
3015                                                            subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data,
3016                                                            true)))
3017                 {
3018                         result = false;
3019                 }
3020         }
3021
3022         /* Done */
3023         if (true == result)
3024         {
3025                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3026         }
3027         else
3028         {
3029                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
3030         }
3031
3032         return tcu::TestNode::STOP;
3033 }
3034
3035 /** Verify result of getProgramStageiv
3036  *
3037  * @param program_id Program object id
3038  * @param pname      <pname> parameter for getProgramStageiv
3039  * @param expected   Expected value
3040  *
3041  * @return true if result is equal to expected value, flase otherwise
3042  **/
3043 bool FunctionalTest3_4::checkProgramStageiv(glw::GLuint program_id, glw::GLenum pname, glw::GLint expected) const
3044 {
3045         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3046         GLint                             value = 0;
3047
3048         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, pname, &value);
3049         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3050
3051         if (expected != value)
3052         {
3053                 m_context.getTestContext().getLog() << tcu::TestLog::Message
3054                                                                                         << "Error. Invalid result. Function: getProgramStageiv. "
3055                                                                                         << "pname: " << Utils::pnameToStr(pname) << ". "
3056                                                                                         << "Result: " << value << ". "
3057                                                                                         << "Expected: " << expected << "." << tcu::TestLog::EndMessage;
3058
3059                 return false;
3060         }
3061         else
3062         {
3063                 return true;
3064         }
3065 }
3066
3067 /** Verify result of getProgramResourceiv
3068  *
3069  * @param program_id        Program object id
3070  * @param program_interface Program interface
3071  * @param pname             <pname> parameter for getProgramStageiv
3072  * @param resource_name     Resource name
3073  * @param expected          Expected value
3074  *
3075  * @return true if result is equal to expected value, false otherwise
3076  **/
3077 bool FunctionalTest3_4::checkProgramResourceiv(GLuint program_id, GLenum program_interface, GLenum pname,
3078                                                                                            const glw::GLchar* resource_name, GLint expected) const
3079 {
3080         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3081         GLuint                            index = gl.getProgramResourceIndex(program_id, program_interface, resource_name);
3082         GLint                             value = 0;
3083
3084         if (GL_INVALID_INDEX == index)
3085         {
3086                 return false;
3087         }
3088
3089         gl.getProgramResourceiv(program_id, program_interface, index, 1, &pname, 1, 0, &value);
3090         GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceiv");
3091
3092         if (expected != value)
3093         {
3094                 m_context.getTestContext().getLog()
3095                         << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramResourceiv. "
3096                         << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". "
3097                         << "Resource name: " << resource_name << ". "
3098                         << "Property: " << Utils::pnameToStr(pname) << ". "
3099                         << "Result: " << value << ". "
3100                         << "Expected: " << expected << "." << tcu::TestLog::EndMessage;
3101
3102                 return false;
3103         }
3104         else
3105         {
3106                 return true;
3107         }
3108 }
3109
3110 /** Verify result of getProgramInterfaceiv
3111  *
3112  * @param program_id        Program object id
3113  * @param program_interface Program interface
3114  * @param pname             <pname> parameter for getProgramStageiv
3115  * @param expected          Expected value
3116  *
3117  * @return true if result is equal to expected value, flase otherwise
3118  **/
3119 bool FunctionalTest3_4::checkProgramInterfaceiv(GLuint program_id, GLenum program_interface, GLenum pname,
3120                                                                                                 GLint expected) const
3121 {
3122         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3123         GLint                             value = 0;
3124
3125         gl.getProgramInterfaceiv(program_id, program_interface, pname, &value);
3126         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInterfaceiv");
3127
3128         if (expected != value)
3129         {
3130                 m_context.getTestContext().getLog()
3131                         << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramInterfaceiv. "
3132                         << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". "
3133                         << "pname: " << Utils::pnameToStr(pname) << ". "
3134                         << "Result: " << value << ". "
3135                         << "Expected: " << expected << "." << tcu::TestLog::EndMessage;
3136
3137                 return false;
3138         }
3139         else
3140         {
3141                 return true;
3142         }
3143 }
3144
3145 /** Verify result of getActiveSubroutineUniformiv
3146  *
3147  * @param program_id Program object id
3148  * @param index      <index> parameter for getActiveSubroutineUniformiv
3149  * @param pname      <pname> parameter for getActiveSubroutineUniformiv
3150  * @param expected   Expected value
3151  *
3152  * @return true if result is equal to expected value, flase otherwise
3153  **/
3154 bool FunctionalTest3_4::checkActiveSubroutineUniformiv(GLuint program_id, GLuint index, GLenum pname,
3155                                                                                                            GLint expected) const
3156 {
3157         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3158         GLint                             value = 0;
3159
3160         gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, index, pname, &value);
3161         GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv");
3162
3163         if (expected != value)
3164         {
3165                 m_context.getTestContext().getLog() << tcu::TestLog::Message
3166                                                                                         << "Error. Invalid result. Function: getActiveSubroutineUniformiv. "
3167                                                                                         << "idnex: " << index << ". "
3168                                                                                         << "pname: " << Utils::pnameToStr(pname) << ". "
3169                                                                                         << "Result: " << value << ". "
3170                                                                                         << "Expected: " << expected << "." << tcu::TestLog::EndMessage;
3171
3172                 return false;
3173         }
3174         else
3175         {
3176                 return true;
3177         }
3178 }
3179
3180 /** Returns index of program resource
3181  *
3182  * @param program_id        Program object id
3183  * @param program_interface Program interface
3184  * @param resource_name     Name of resource
3185  *
3186  * @return Index of specified resource
3187  **/
3188 GLuint FunctionalTest3_4::getProgramResourceIndex(GLuint program_id, GLenum program_interface,
3189                                                                                                   const glw::GLchar* resource_name) const
3190 {
3191         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3192         GLuint                            index = gl.getProgramResourceIndex(program_id, program_interface, resource_name);
3193
3194         GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceIndex");
3195
3196         if (GL_INVALID_INDEX == index)
3197         {
3198                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Program resource is not available. "
3199                                                                                         << "Program interface: " << Utils::programInterfaceToStr(program_interface)
3200                                                                                         << ". "
3201                                                                                         << "Resource name: " << resource_name << "." << tcu::TestLog::EndMessage;
3202         }
3203
3204         return index;
3205 }
3206
3207 /** Get subroutine index
3208  *
3209  * @param program_id        Program object id
3210  * @param subroutine_name   Subroutine name
3211  * @param use_program_query If true getProgramResourceIndex is used, otherwise getSubroutineIndex
3212  *
3213  * @return Index of subroutine
3214  **/
3215 GLuint FunctionalTest3_4::getSubroutineIndex(GLuint program_id, const glw::GLchar* subroutine_name,
3216                                                                                          bool use_program_query) const
3217 {
3218         const glw::Functions& gl        = m_context.getRenderContext().getFunctions();
3219         GLuint                            index = -1;
3220
3221         if (false == use_program_query)
3222         {
3223                 index = gl.getSubroutineIndex(program_id, GL_VERTEX_SHADER, subroutine_name);
3224                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex");
3225         }
3226         else
3227         {
3228                 index = gl.getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE, subroutine_name);
3229                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceIndex");
3230         }
3231
3232         if (GL_INVALID_INDEX == index)
3233         {
3234                 TCU_FAIL("Subroutine is not available");
3235         }
3236
3237         return index;
3238 }
3239
3240 /** Get subroutine uniform location
3241  *
3242  * @param program_id        Program object id
3243  * @param uniform_name      Subroutine uniform name
3244  * @param use_program_query If true getProgramResourceLocation is used, otherwise getSubroutineUniformLocation
3245  *
3246  * @return Location of subroutine uniform
3247  **/
3248 GLint FunctionalTest3_4::getSubroutineUniformLocation(GLuint program_id, const glw::GLchar* uniform_name,
3249                                                                                                           bool use_program_query) const
3250 {
3251         const glw::Functions& gl           = m_context.getRenderContext().getFunctions();
3252         GLint                             location = -1;
3253
3254         if (false == use_program_query)
3255         {
3256                 location = gl.getSubroutineUniformLocation(program_id, GL_VERTEX_SHADER, uniform_name);
3257                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation");
3258         }
3259         else
3260         {
3261                 location = gl.getProgramResourceLocation(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name);
3262                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceLocation");
3263         }
3264
3265         if (-1 == location)
3266         {
3267                 TCU_FAIL("Subroutine uniform is not available");
3268         }
3269
3270         return location;
3271 }
3272
3273 /** Test if getProgramStageiv results are as expected
3274  *
3275  * @param program_id Program object id
3276  *
3277  * @result false in case of invalid result for any pname, true otherwise
3278  **/
3279 bool FunctionalTest3_4::inspectProgramStageiv(glw::GLuint program_id) const
3280 {
3281         bool result = true;
3282
3283         const inspectionDetails details[] = {
3284                 { GL_ACTIVE_SUBROUTINE_UNIFORMS, m_n_active_subroutine_uniforms },
3285                 { GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, m_n_active_subroutine_uniform_locations },
3286                 { GL_ACTIVE_SUBROUTINES, m_n_active_subroutines },
3287                 { GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH, m_n_active_subroutine_uniform_name_length + 1 },
3288                 { GL_ACTIVE_SUBROUTINE_MAX_LENGTH, m_n_active_subroutine_name_length + 1 }
3289         };
3290         const GLuint n_details = sizeof(details) / sizeof(details[0]);
3291
3292         for (GLuint i = 0; i < n_details; ++i)
3293         {
3294                 if (false == checkProgramStageiv(program_id, details[i].pname, details[i].expected_value))
3295                 {
3296                         result = false;
3297                 }
3298         }
3299
3300         return result;
3301 }
3302
3303 /** Test if checkProgramInterfaceiv results are as expected
3304  *
3305  * @param program_id Program object id
3306  *
3307  * @result false in case of invalid result for any pname, true otherwise
3308  **/
3309 bool FunctionalTest3_4::inspectProgramInterfaceiv(glw::GLuint program_id) const
3310 {
3311         bool result = true;
3312
3313         const inspectionDetailsForProgramInterface details[] = {
3314                 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_ACTIVE_RESOURCES, m_n_active_subroutine_uniforms },
3315                 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NAME_LENGTH, m_n_active_subroutine_uniform_name_length + 1 },
3316                 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines },
3317                 { GL_VERTEX_SUBROUTINE, GL_ACTIVE_RESOURCES, m_n_active_subroutines },
3318                 { GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, m_n_active_subroutine_name_length + 1 }
3319         };
3320         const GLuint n_details = sizeof(details) / sizeof(details[0]);
3321
3322         for (GLuint i = 0; i < n_details; ++i)
3323         {
3324                 if (false == checkProgramInterfaceiv(program_id, details[i].program_interface, details[i].pname,
3325                                                                                          details[i].expected_value))
3326                 {
3327                         result = false;
3328                 }
3329         }
3330
3331         return result;
3332 }
3333
3334 /** Test if checkProgramResourceiv results are as expected
3335  *
3336  * @param program_id       Program object id
3337  * @param subroutine_names Array of subroutine names
3338  * @param uniform_names    Array of uniform names
3339  *
3340  * @result false in case of invalid result for any pname, true otherwise
3341  **/
3342 bool FunctionalTest3_4::inspectProgramResourceiv(GLuint program_id, const GLchar** subroutine_names,
3343                                                                                                  const GLchar** uniform_names) const
3344 {
3345         const glw::Functions& gl         = m_context.getRenderContext().getFunctions();
3346         bool                              result = true;
3347
3348         for (GLint subroutine = 0; subroutine < m_n_active_subroutines; ++subroutine)
3349         {
3350                 const GLchar* subroutine_name = subroutine_names[subroutine];
3351                 const GLint   length              = (GLint)strlen(subroutine_name) + 1;
3352
3353                 if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE, GL_NAME_LENGTH, subroutine_name, length))
3354                 {
3355                         result = false;
3356                 }
3357         }
3358
3359         inspectionDetails details[] = {
3360                 { GL_NAME_LENGTH, 0 },
3361                 { GL_ARRAY_SIZE, 1 },
3362                 { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines },
3363                 { GL_LOCATION, 0 },
3364         };
3365         const GLuint n_details = sizeof(details) / sizeof(details[0]);
3366
3367         for (GLint uniform = 0; uniform < m_n_active_subroutine_uniforms; ++uniform)
3368         {
3369                 const GLchar* uniform_name = uniform_names[uniform];
3370                 const GLint   length       = (GLint)strlen(uniform_name) + 1;
3371                 const GLint   location   = getSubroutineUniformLocation(program_id, uniform_name, true);
3372
3373                 details[0].expected_value = length;
3374                 details[3].expected_value = location;
3375
3376                 for (GLuint i = 0; i < n_details; ++i)
3377                 {
3378                         if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, details[i].pname,
3379                                                                                                 uniform_name, details[i].expected_value))
3380                         {
3381                                 result = false;
3382                         }
3383                 }
3384
3385                 /* Check compatible subroutines */
3386                 GLuint index = getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name);
3387
3388                 if (GL_INVALID_INDEX != index)
3389                 {
3390                         std::vector<GLint> compatible_subroutines;
3391                         GLint                      index_sum = 0;
3392                         GLenum                     prop          = GL_COMPATIBLE_SUBROUTINES;
3393
3394                         compatible_subroutines.resize(m_n_active_subroutines);
3395
3396                         gl.getProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, index, 1, &prop, m_n_active_subroutines,
3397                                                                         0, &compatible_subroutines[0]);
3398
3399                         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceiv");
3400
3401                         /* Expected indices are 0, 1, 2, ... N */
3402                         for (GLint i = 0; i < m_n_active_subroutines; ++i)
3403                         {
3404                                 index_sum += compatible_subroutines[i];
3405                         }
3406
3407                         /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */
3408                         if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum)
3409                         {
3410                                 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
3411
3412                                 message << "Error. Invalid result. Function: getProgramResourceiv. "
3413                                                 << "Program interface: GL_VERTEX_SUBROUTINE_UNIFORM. "
3414                                                 << "Resource name: " << uniform_name << ". "
3415                                                 << "Property: GL_COMPATIBLE_SUBROUTINES. "
3416                                                 << "Results: ";
3417
3418                                 for (GLint i = 1; i < m_n_active_subroutines; ++i)
3419                                 {
3420                                         message << compatible_subroutines[i];
3421                                 }
3422
3423                                 message << tcu::TestLog::EndMessage;
3424
3425                                 result = false;
3426                         }
3427                 }
3428         }
3429
3430         return result;
3431 }
3432
3433 /** Test if getActiveSubroutineUniformiv results are as expected
3434  *
3435  * @param program_id    Program object id
3436  * @param uniform_names Array of subroutine uniform names available in program
3437  *
3438  * @result false in case of invalid result for any pname, true otherwise
3439  **/
3440 bool FunctionalTest3_4::inspectActiveSubroutineUniformiv(GLuint program_id, const GLchar** uniform_names) const
3441 {
3442         const glw::Functions& gl                                                   = m_context.getRenderContext().getFunctions();
3443         bool                              result                                           = true;
3444         GLint                             n_active_subroutine_uniforms = 0;
3445
3446         inspectionDetails details[] = {
3447                 { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines },
3448                 { GL_UNIFORM_SIZE, m_n_active_subroutine_uniform_size },
3449                 { GL_UNIFORM_NAME_LENGTH, 0 },
3450         };
3451         const GLuint n_details = sizeof(details) / sizeof(details[0]);
3452
3453         /* Get amount of active subroutine uniforms */
3454         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms);
3455         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3456
3457         for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform)
3458         {
3459                 GLint name_length = (GLint)strlen(uniform_names[uniform]);
3460
3461                 details[2].expected_value = name_length + 1;
3462
3463                 /* Checks from "details" */
3464                 for (GLuint i = 0; i < n_details; ++i)
3465                 {
3466                         if (false ==
3467                                 checkActiveSubroutineUniformiv(program_id, uniform, details[i].pname, details[i].expected_value))
3468                         {
3469                                 result = false;
3470                         }
3471                 }
3472
3473                 /* Check compatible subroutines */
3474                 std::vector<GLint> compatible_subroutines;
3475                 compatible_subroutines.resize(m_n_active_subroutines);
3476                 GLint index_sum = 0;
3477
3478                 gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, uniform, GL_COMPATIBLE_SUBROUTINES,
3479                                                                                 &compatible_subroutines[0]);
3480                 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv");
3481
3482                 /* Expected indices are 0, 1, 2, ... N */
3483                 for (GLint i = 0; i < m_n_active_subroutines; ++i)
3484                 {
3485                         index_sum += compatible_subroutines[i];
3486                 }
3487
3488                 /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */
3489                 if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum)
3490                 {
3491                         tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
3492
3493                         message << "Error. Invalid result. Function: getActiveSubroutineUniformiv. idnex: " << uniform
3494                                         << ". pname: " << Utils::pnameToStr(GL_COMPATIBLE_SUBROUTINES) << ". Results: ";
3495
3496                         for (GLint i = 1; i < m_n_active_subroutines; ++i)
3497                         {
3498                                 message << compatible_subroutines[i];
3499                         }
3500
3501                         message << tcu::TestLog::EndMessage;
3502
3503                         result = false;
3504                 }
3505         }
3506
3507         return result;
3508 }
3509
3510 /** Test if getActiveSubroutineUniformName results are as expected
3511  *
3512  * @param program_id    Program object id
3513  * @param uniform_names Array of subroutine uniform names available in program
3514  *
3515  * @result false in case of invalid result, true otherwise
3516  **/
3517 bool FunctionalTest3_4::inspectActiveSubroutineUniformName(GLuint program_id, const GLchar** uniform_names) const
3518 {
3519         const glw::Functions& gl                                                   = m_context.getRenderContext().getFunctions();
3520         bool                              result                                           = true;
3521         GLint                             n_active_subroutine_uniforms = 0;
3522         std::vector<GLchar>   active_uniform_name;
3523
3524         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms);
3525         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3526
3527         active_uniform_name.resize(m_n_active_subroutine_uniform_name_length + 1);
3528
3529         for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform)
3530         {
3531                 bool is_name_ok = false;
3532
3533                 gl.getActiveSubroutineUniformName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_uniform_name.size(),
3534                                                                                   0 /* length */, &active_uniform_name[0]);
3535                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveSubroutineUniformName");
3536
3537                 for (GLint name = 0; name < n_active_subroutine_uniforms; ++name)
3538                 {
3539                         if (0 == strcmp(uniform_names[name], &active_uniform_name[0]))
3540                         {
3541                                 is_name_ok = true;
3542                                 break;
3543                         }
3544                 }
3545
3546                 if (false == is_name_ok)
3547                 {
3548                         m_context.getTestContext().getLog()
3549                                 << tcu::TestLog::Message
3550                                 << "Error. Invalid result. Function: getActiveSubroutineUniformName. idnex: " << uniform
3551                                 << ". Result: " << &active_uniform_name[0] << tcu::TestLog::EndMessage;
3552
3553                         result = false;
3554                         break;
3555                 }
3556         }
3557
3558         return result;
3559 }
3560
3561 /** Test if getActiveSubroutineUniformName results are as expected
3562  *
3563  * @param program_id       Program object id
3564  * @param subroutine_names Array of subroutine names available in program
3565  *
3566  * @result false in case of invalid result, true otherwise
3567  **/
3568 bool FunctionalTest3_4::inspectActiveSubroutineName(GLuint program_id, const GLchar** subroutine_names) const
3569 {
3570         const glw::Functions& gl                                   = m_context.getRenderContext().getFunctions();
3571         bool                              result                           = true;
3572         GLint                             n_active_subroutines = 0;
3573         std::vector<GLchar>   active_subroutine_name;
3574
3575         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines);
3576         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3577
3578         active_subroutine_name.resize(m_n_active_subroutine_name_length + 1);
3579
3580         for (GLint uniform = 0; uniform < n_active_subroutines; ++uniform)
3581         {
3582                 bool is_name_ok = false;
3583
3584                 gl.getActiveSubroutineName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_subroutine_name.size(),
3585                                                                    0 /* length */, &active_subroutine_name[0]);
3586                 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineName");
3587
3588                 for (GLint name = 0; name < n_active_subroutines; ++name)
3589                 {
3590                         if (0 == strcmp(subroutine_names[name], &active_subroutine_name[0]))
3591                         {
3592                                 is_name_ok = true;
3593                                 break;
3594                         }
3595                 }
3596
3597                 if (false == is_name_ok)
3598                 {
3599                         m_context.getTestContext().getLog()
3600                                 << tcu::TestLog::Message
3601                                 << "Error. Invalid result. Function: getActiveSubroutineName. idnex: " << uniform
3602                                 << ". Result: " << &active_subroutine_name[0] << tcu::TestLog::EndMessage;
3603
3604                         result = false;
3605                         break;
3606                 }
3607         }
3608
3609         return result;
3610 }
3611
3612 /** Test if it is possible to "bind" all subroutines uniforms with all subroutines
3613  *
3614  * @param program_id       Program object id
3615  * @param subroutine_names Array of subroutine names available in program
3616  * @param uniform_names    Array of subroutine uniform names available in program
3617  *
3618  * @result false in case of invalid result, true otherwise
3619  **/
3620 bool FunctionalTest3_4::inspectSubroutineBinding(GLuint program_id, const GLchar** subroutine_names,
3621                                                                                                  const GLchar** uniform_names, bool use_program_query) const
3622 {
3623         const glw::Functions& gl                                                   = m_context.getRenderContext().getFunctions();
3624         bool                              result                                           = true;
3625         GLint                             n_active_subroutines             = 0;
3626         GLint                             n_active_subroutine_uniforms = 0;
3627         std::vector<GLuint>   subroutine_uniforms;
3628         GLuint                            queried_subroutine_index = 0;
3629
3630         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines);
3631         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3632
3633         gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms);
3634         GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv");
3635
3636         subroutine_uniforms.resize(n_active_subroutine_uniforms);
3637
3638         for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform)
3639         {
3640                 GLuint uniform_location = getSubroutineUniformLocation(program_id, uniform_names[uniform], use_program_query);
3641
3642                 for (GLint routine = 0; routine < n_active_subroutines; ++routine)
3643                 {
3644                         GLuint routine_index = getSubroutineIndex(program_id, subroutine_names[routine], use_program_query);
3645
3646                         subroutine_uniforms[uniform] = routine_index;
3647
3648                         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_active_subroutine_uniforms, &subroutine_uniforms[0]);
3649                         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
3650
3651                         gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, uniform_location, &queried_subroutine_index);
3652                         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
3653
3654                         if (queried_subroutine_index != routine_index)
3655                         {
3656                                 m_context.getTestContext().getLog()
3657                                         << tcu::TestLog::Message << "Error. Invalid result. Function: gl.getUniformSubroutineuiv."
3658                                         << " Subroutine uniform: " << uniform << ", name: " << uniform_names[uniform]
3659                                         << ", location: " << uniform_location << ". Subroutine: " << routine
3660                                         << ", name: " << subroutine_names[routine] << ", index: " << routine_index
3661                                         << ". Result: " << queried_subroutine_index << tcu::TestLog::EndMessage;
3662
3663                                 result = false;
3664                         }
3665                 }
3666         }
3667
3668         return result;
3669 }
3670
3671 /** Execute draw call and verify results
3672  *
3673  * @param program_id                   Program object id
3674  * @param first_routine_name           Name of subroutine that shall be used aas first_routine
3675  * @param second_routine_name          Name of subroutine that shall be used aas second_routine
3676  * @param uniform_names                Name of uniforms
3677  * @param expected_results             Test data. [0] is used as input data. All are used as expected_results
3678  * @param use_program_query            If true GetProgram* API will be used
3679  *
3680  * @return false in case of invalid result, true otherwise
3681  **/
3682 bool FunctionalTest3_4::testDraw(GLuint program_id, const GLchar* first_routine_name, const GLchar* second_routine_name,
3683                                                                  const GLchar** uniform_names, const Utils::vec4<GLfloat> expected_results[5],
3684                                                                  bool use_program_query) const
3685 {
3686         static const GLuint   n_varyings                         = 5;
3687         const glw::Functions& gl                                         = m_context.getRenderContext().getFunctions();
3688         bool                              result                                 = true;
3689         GLuint                            subroutine_uniforms[2] = { 0 };
3690
3691         /* Get subroutine uniform locations */
3692         GLint first_routine_location = getSubroutineUniformLocation(program_id, uniform_names[0], use_program_query);
3693
3694         GLint second_routine_location = getSubroutineUniformLocation(program_id, uniform_names[1], use_program_query);
3695
3696         /* Get subroutine indices */
3697         GLuint first_routine_index = getSubroutineIndex(program_id, first_routine_name, use_program_query);
3698
3699         GLuint second_routine_index = getSubroutineIndex(program_id, second_routine_name, use_program_query);
3700
3701         /* Map uniforms with subroutines */
3702         subroutine_uniforms[first_routine_location]  = first_routine_index;
3703         subroutine_uniforms[second_routine_location] = second_routine_index;
3704
3705         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 2 /* number of uniforms */, &subroutine_uniforms[0]);
3706         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
3707
3708         /* Get location of input_data */
3709         GLint input_data_location = gl.getUniformLocation(program_id, "input_data");
3710         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation");
3711
3712         if (-1 == input_data_location)
3713         {
3714                 TCU_FAIL("Uniform is not available");
3715         }
3716
3717         /* Set up input_data */
3718         gl.uniform4f(input_data_location, expected_results[0].m_x, expected_results[0].m_y, expected_results[0].m_z,
3719                                  expected_results[0].m_w);
3720         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
3721
3722         /* Execute draw call with transform feedback */
3723         gl.beginTransformFeedback(GL_POINTS);
3724         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
3725
3726         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
3727         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
3728
3729         gl.endTransformFeedback();
3730         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
3731
3732         /* Verify results */
3733         GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
3734         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
3735
3736         Utils::vec4<GLfloat> results[5];
3737
3738         results[0].m_x = feedback_data[0];
3739         results[0].m_y = feedback_data[1];
3740         results[0].m_z = feedback_data[2];
3741         results[0].m_w = feedback_data[3];
3742
3743         results[1].m_x = feedback_data[4];
3744         results[1].m_y = feedback_data[5];
3745         results[1].m_z = feedback_data[6];
3746         results[1].m_w = feedback_data[7];
3747
3748         results[2].m_x = feedback_data[8];
3749         results[2].m_y = feedback_data[9];
3750         results[2].m_z = feedback_data[10];
3751         results[2].m_w = feedback_data[11];
3752
3753         results[3].m_x = feedback_data[12];
3754         results[3].m_y = feedback_data[13];
3755         results[3].m_z = feedback_data[14];
3756         results[3].m_w = feedback_data[15];
3757
3758         results[4].m_x = feedback_data[16];
3759         results[4].m_y = feedback_data[17];
3760         results[4].m_z = feedback_data[18];
3761         results[4].m_w = feedback_data[19];
3762
3763         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
3764         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
3765
3766         for (GLuint i = 0; i < n_varyings; ++i)
3767         {
3768                 result = result && (results[i] == expected_results[i]);
3769         }
3770
3771         if (false == result)
3772         {
3773                 m_context.getTestContext().getLog() << tcu::TestLog::Message
3774                                                                                         << "Error. Invalid result. First routine: " << first_routine_name
3775                                                                                         << ". Second routine: " << second_routine_name << tcu::TestLog::EndMessage;
3776
3777                 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
3778
3779                 message << "Results:";
3780
3781                 for (GLuint i = 0; i < n_varyings; ++i)
3782                 {
3783                         results[i].log(message);
3784                 }
3785
3786                 message << tcu::TestLog::EndMessage;
3787
3788                 message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
3789
3790                 message << "Expected:";
3791
3792                 for (GLuint i = 0; i < n_varyings; ++i)
3793                 {
3794                         expected_results[i].log(message);
3795                 }
3796
3797                 message << tcu::TestLog::EndMessage;
3798         }
3799
3800         return result;
3801 }
3802
3803 /** Constructor
3804  *
3805  * @param context CTS context
3806  **/
3807 FunctionalTest5::FunctionalTest5(deqp::Context& context)
3808         : TestCase(context, "eight_subroutines_four_uniforms", "Verify multiple subroutine sets")
3809 {
3810 }
3811
3812 /** Execute test
3813  *
3814  * @return tcu::TestNode::STOP
3815  **/
3816 tcu::TestNode::IterateResult FunctionalTest5::iterate()
3817 {
3818         static const GLchar* vertex_shader_code =
3819                 "#version 400 core\n"
3820                 "#extension GL_ARB_shader_subroutine : require\n"
3821                 "\n"
3822                 "precision highp float;\n"
3823                 "\n"
3824                 "// Subroutine types\n"
3825                 "subroutine vec4  routine_type_1(in vec4 left, in vec4 right);\n"
3826                 "subroutine vec4  routine_type_2(in vec4 iparam);\n"
3827                 "subroutine vec4  routine_type_3(in vec4 a,    in vec4 b,    in vec4 c);\n"
3828                 "subroutine bvec4 routine_type_4(in vec4 left, in vec4 right);\n"
3829                 "\n"
3830                 "// Subroutine definitions\n"
3831                 "// 1st type\n"
3832                 "subroutine(routine_type_1) vec4 add(in vec4 left, in vec4 right)\n"
3833                 "{\n"
3834                 "    return left + right;\n"
3835                 "}\n"
3836                 "\n"
3837                 "subroutine(routine_type_1) vec4 subtract(in vec4 left, in vec4 right)\n"
3838                 "{\n"
3839                 "    return left - right;\n"
3840                 "}\n"
3841                 "\n"
3842                 "// 2nd type\n"
3843                 "subroutine(routine_type_2) vec4 square(in vec4 iparam)\n"
3844                 "{\n"
3845                 "    return iparam * iparam;\n"
3846                 "}\n"
3847                 "\n"
3848                 "subroutine(routine_type_2) vec4 square_root(in vec4 iparam)\n"
3849                 "{\n"
3850                 "    return sqrt(iparam);\n"
3851                 "}\n"
3852                 "\n"
3853                 "// 3rd type\n"
3854                 "subroutine(routine_type_3) vec4 do_fma(in vec4 a, in vec4 b, in vec4 c)\n"
3855                 "{\n"
3856                 "    return fma(a, b, c);\n"
3857                 "}\n"
3858                 "\n"
3859                 "subroutine(routine_type_3) vec4 blend(in vec4 a, in vec4 b, in vec4 c)\n"
3860                 "{\n"
3861                 "    return c * a + (vec4(1) - c) * b;\n"
3862                 "}\n"
3863                 "\n"
3864                 "// 4th type\n"
3865                 "subroutine(routine_type_4) bvec4 are_equal(in vec4 left, in vec4 right)\n"
3866                 "{\n"
3867                 "    return equal(left, right);\n"
3868                 "}\n"
3869                 "\n"
3870                 "subroutine(routine_type_4) bvec4 are_greater(in vec4 left, in vec4 right)\n"
3871                 "{\n"
3872                 "    return greaterThan(left, right);\n"
3873                 "}\n"
3874                 "\n"
3875                 "// Sub routine uniforms\n"
3876                 "subroutine uniform routine_type_1 first_routine;\n"
3877                 "subroutine uniform routine_type_2 second_routine;\n"
3878                 "subroutine uniform routine_type_3 third_routine;\n"
3879                 "subroutine uniform routine_type_4 fourth_routine;\n"
3880                 "\n"
3881                 "// Input data\n"
3882                 "uniform vec4 first_input;\n"
3883                 "uniform vec4 second_input;\n"
3884                 "uniform vec4 third_input;\n"
3885                 "\n"
3886                 "// Output\n"
3887                 "out  vec4 out_result_from_first_routine;\n"
3888                 "out  vec4 out_result_from_second_routine;\n"
3889                 "out  vec4 out_result_from_third_routine;\n"
3890                 "out uvec4 out_result_from_fourth_routine;\n"
3891                 "\n"
3892                 "void main()\n"
3893                 "{\n"
3894                 "    out_result_from_first_routine  =       first_routine (first_input, second_input);\n"
3895                 "    out_result_from_second_routine =       second_routine(first_input);\n"
3896                 "    out_result_from_third_routine  =       third_routine (first_input, second_input, third_input);\n"
3897                 "    out_result_from_fourth_routine = uvec4(fourth_routine(first_input, second_input));\n"
3898                 "}\n"
3899                 "\n";
3900
3901         static const GLchar* subroutine_names[4][2] = {
3902                 { "add", "subtract" }, { "square", "square_root" }, { "do_fma", "blend" }, { "are_equal", "are_greater" }
3903         };
3904
3905         static const GLchar* subroutine_uniform_names[4][1] = {
3906                 { "first_routine" }, { "second_routine" }, { "third_routine" }, { "fourth_routine" }
3907         };
3908
3909         static const GLuint n_subroutine_types   = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
3910         static const GLuint n_subroutines_per_type = sizeof(subroutine_names[0]) / sizeof(subroutine_names[0][0]);
3911         static const GLuint n_subroutine_uniforms_per_type =
3912                 sizeof(subroutine_uniform_names[0]) / sizeof(subroutine_uniform_names[0][0]);
3913
3914         static const GLchar* uniform_names[] = { "first_input", "second_input", "third_input" };
3915         static const GLuint  n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]);
3916
3917         static const GLchar* varying_names[] = { "out_result_from_first_routine", "out_result_from_second_routine",
3918                                                                                          "out_result_from_third_routine", "out_result_from_fourth_routine" };
3919         static const GLuint n_varyings                                     = sizeof(varying_names) / sizeof(varying_names[0]);
3920         static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */;
3921
3922         /* Test data */
3923         static const Utils::vec4<GLfloat> input_data[3] = { Utils::vec4<GLfloat>(1.0f, 4.0f, 9.0f, 16.0f),
3924                                                                                                                 Utils::vec4<GLfloat>(16.0f, 9.0f, 4.0f, 1.0f),
3925                                                                                                                 Utils::vec4<GLfloat>(0.25f, 0.5f, 0.75f, 1.0f) };
3926
3927         static const Utils::vec4<GLfloat> expected_result_from_first_routine[2] = {
3928                 Utils::vec4<GLfloat>(17.0f, 13.0f, 13.0f, 17.0f), Utils::vec4<GLfloat>(-15.0f, -5.0f, 5.0f, 15.0f)
3929         };
3930
3931         static const Utils::vec4<GLfloat> expected_result_from_second_routine[2] = {
3932                 Utils::vec4<GLfloat>(1.0f, 16.0f, 81.0f, 256.0f), Utils::vec4<GLfloat>(1.0f, 2.0f, 3.0f, 4.0f)
3933         };
3934
3935         static const Utils::vec4<GLfloat> expected_result_from_third_routine[2] = {
3936                 Utils::vec4<GLfloat>(16.25f, 36.5f, 36.75f, 17.0f), Utils::vec4<GLfloat>(12.25f, 6.5f, 7.75f, 16.0f)
3937         };
3938
3939         static const Utils::vec4<GLuint> expected_result_from_fourth_routine[2] = { Utils::vec4<GLuint>(0, 0, 0, 0),
3940                                                                                                                                                                 Utils::vec4<GLuint>(0, 0, 1, 1) };
3941
3942         /* All combinations of subroutines */
3943         static const GLuint subroutine_combinations[][4] = {
3944                 { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 0, 1, 1 }, { 0, 1, 0, 0 }, { 0, 1, 0, 1 },
3945                 { 0, 1, 1, 0 }, { 0, 1, 1, 1 }, { 1, 0, 0, 0 }, { 1, 0, 0, 1 }, { 1, 0, 1, 0 }, { 1, 0, 1, 1 },
3946                 { 1, 1, 0, 0 }, { 1, 1, 0, 1 }, { 1, 1, 1, 0 }, { 1, 1, 1, 1 }
3947         };
3948         static const GLuint n_subroutine_combinations =
3949                 sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]);
3950
3951         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
3952         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
3953         {
3954                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
3955         }
3956
3957         /* Result */
3958         bool result = true;
3959
3960         /* GL objects */
3961         Utils::program   program(m_context);
3962         Utils::buffer     transform_feedback_buffer(m_context);
3963         Utils::vertexArray vao(m_context);
3964
3965         /* Init GL objects */
3966         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names,
3967                                   n_varyings);
3968
3969         program.use();
3970
3971         vao.generate();
3972         vao.bind();
3973
3974         transform_feedback_buffer.generate();
3975         transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
3976                                                                          GL_DYNAMIC_COPY);
3977         transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
3978
3979         /* Get subroutine uniform locations and subroutine indices */
3980         for (GLuint type = 0; type < n_subroutine_types; ++type)
3981         {
3982                 for (GLuint uniform = 0; uniform < n_subroutine_uniforms_per_type; ++uniform)
3983                 {
3984                         m_subroutine_uniform_locations[type][uniform] =
3985                                 program.getSubroutineUniformLocation(subroutine_uniform_names[type][uniform], GL_VERTEX_SHADER);
3986                 }
3987
3988                 for (GLuint routine = 0; routine < n_subroutines_per_type; ++routine)
3989                 {
3990                         m_subroutine_indices[type][routine] =
3991                                 program.getSubroutineIndex(subroutine_names[type][routine], GL_VERTEX_SHADER);
3992                 }
3993         }
3994
3995         /* Get uniform locations */
3996         for (GLuint i = 0; i < n_uniform_names; ++i)
3997         {
3998                 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]);
3999         }
4000
4001         /* Draw with each routine combination */
4002         for (GLuint i = 0; i < n_subroutine_combinations; ++i)
4003         {
4004                 Utils::vec4<GLfloat> first_routine_result;
4005                 Utils::vec4<GLfloat> second_routine_result;
4006                 Utils::vec4<GLfloat> third_routine_result;
4007                 Utils::vec4<GLuint>  fourth_routine_result;
4008
4009                 testDraw(subroutine_combinations[i], input_data, first_routine_result, second_routine_result,
4010                                  third_routine_result, fourth_routine_result);
4011
4012                 if (false == verify(first_routine_result, second_routine_result, third_routine_result, fourth_routine_result,
4013                                                         expected_result_from_first_routine[subroutine_combinations[i][0]],
4014                                                         expected_result_from_second_routine[subroutine_combinations[i][1]],
4015                                                         expected_result_from_third_routine[subroutine_combinations[i][2]],
4016                                                         expected_result_from_fourth_routine[subroutine_combinations[i][3]]))
4017                 {
4018                         logError(subroutine_names, subroutine_combinations[i], input_data, first_routine_result,
4019                                          second_routine_result, third_routine_result, fourth_routine_result,
4020                                          expected_result_from_first_routine[subroutine_combinations[i][0]],
4021                                          expected_result_from_second_routine[subroutine_combinations[i][1]],
4022                                          expected_result_from_third_routine[subroutine_combinations[i][2]],
4023                                          expected_result_from_fourth_routine[subroutine_combinations[i][3]]);
4024
4025                         result = false;
4026                 }
4027         }
4028
4029         /* Done */
4030         if (true == result)
4031         {
4032                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
4033         }
4034         else
4035         {
4036                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
4037         }
4038
4039         return tcu::TestNode::STOP;
4040 }
4041
4042 /** Log error message
4043  *
4044  * @param subroutine_names               Array of subroutine names
4045  * @param subroutine_combination         Combination of subroutines
4046  * @param input_data                     Input data
4047  * @param first_routine_result           Result of first routine
4048  * @param second_routine_result          Result of second routine
4049  * @param third_routine_result           Result of third routine
4050  * @param fourth_routine_result          Result of fourth routine
4051  * @param first_routine_expected_result  Expected result of first routine
4052  * @param second_routine_expected_result Expected result of second routine
4053  * @param third_routine_expected_result  Expected result of third routine
4054  * @param fourth_routine_expected_result Expected result of fourth routine
4055  **/
4056 void FunctionalTest5::logError(const glw::GLchar* subroutine_names[4][2], const glw::GLuint subroutine_combination[4],
4057                                                            const Utils::vec4<glw::GLfloat>  input_data[3],
4058                                                            const Utils::vec4<glw::GLfloat>& first_routine_result,
4059                                                            const Utils::vec4<glw::GLfloat>& second_routine_result,
4060                                                            const Utils::vec4<glw::GLfloat>& third_routine_result,
4061                                                            const Utils::vec4<glw::GLuint>&  fourth_routine_result,
4062                                                            const Utils::vec4<glw::GLfloat>& first_routine_expected_result,
4063                                                            const Utils::vec4<glw::GLfloat>& second_routine_expected_result,
4064                                                            const Utils::vec4<glw::GLfloat>& third_routine_expected_result,
4065                                                            const Utils::vec4<glw::GLuint>&  fourth_routine_expected_result) const
4066 {
4067         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
4068                                                                                 << tcu::TestLog::EndMessage;
4069
4070         tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4071
4072         message << "Function: " << subroutine_names[0][subroutine_combination[0]] << "( ";
4073         input_data[0].log(message);
4074         message << ", ";
4075         input_data[1].log(message);
4076         message << " ). Result: ";
4077         first_routine_result.log(message);
4078         message << ". Expected: ";
4079         first_routine_expected_result.log(message);
4080
4081         message << tcu::TestLog::EndMessage;
4082
4083         message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4084
4085         message << "Function: " << subroutine_names[1][subroutine_combination[1]] << "( ";
4086         input_data[0].log(message);
4087         message << " ). Result: ";
4088         second_routine_result.log(message);
4089         message << ". Expected: ";
4090         second_routine_expected_result.log(message);
4091
4092         message << tcu::TestLog::EndMessage;
4093
4094         message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4095
4096         message << "Function: " << subroutine_names[2][subroutine_combination[2]] << "( ";
4097         input_data[0].log(message);
4098         message << ", ";
4099         input_data[1].log(message);
4100         message << ", ";
4101         input_data[2].log(message);
4102         message << "). Result: ";
4103         third_routine_result.log(message);
4104         message << ". Expected: ";
4105         third_routine_expected_result.log(message);
4106
4107         message << tcu::TestLog::EndMessage;
4108
4109         message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4110
4111         message << "Function: " << subroutine_names[3][subroutine_combination[3]] << "( ";
4112         input_data[0].log(message);
4113         message << ", ";
4114         input_data[1].log(message);
4115         message << ", ";
4116         message << " ). Result: ";
4117         fourth_routine_result.log(message);
4118         message << ". Expected: ";
4119         fourth_routine_expected_result.log(message);
4120
4121         message << tcu::TestLog::EndMessage;
4122 }
4123
4124 /** Execute draw call and capture results
4125  *
4126  * @param subroutine_combination    Combination of subroutines
4127  * @param input_data                Input data
4128  * @param out_first_routine_result  Result of first routine
4129  * @param out_second_routine_result Result of second routine
4130  * @param out_third_routine_result  Result of third routine
4131  * @param out_fourth_routine_result Result of fourth routine
4132  **/
4133 void FunctionalTest5::testDraw(const glw::GLuint                           subroutine_combination[4],
4134                                                            const Utils::vec4<glw::GLfloat> input_data[3],
4135                                                            Utils::vec4<glw::GLfloat>&     out_first_routine_result,
4136                                                            Utils::vec4<glw::GLfloat>&     out_second_routine_result,
4137                                                            Utils::vec4<glw::GLfloat>&     out_third_routine_result,
4138                                                            Utils::vec4<glw::GLuint>&       out_fourth_routine_result) const
4139 {
4140         static const GLuint   n_uniforms = sizeof(m_uniform_locations) / sizeof(m_uniform_locations[0]);
4141         const glw::Functions& gl                 = m_context.getRenderContext().getFunctions();
4142         GLuint                            subroutine_indices[4];
4143         static const GLuint   n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]);
4144
4145         /* Prepare subroutine uniform data */
4146         for (GLuint i = 0; i < n_subroutine_uniforms; ++i)
4147         {
4148                 const GLuint location = m_subroutine_uniform_locations[i][0];
4149
4150                 subroutine_indices[location] = m_subroutine_indices[i][subroutine_combination[i]];
4151         }
4152
4153         /* Set up subroutine uniforms */
4154         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]);
4155         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
4156
4157         /* Set up input data uniforms */
4158         for (GLuint i = 0; i < n_uniforms; ++i)
4159         {
4160                 gl.uniform4f(m_uniform_locations[i], input_data[i].m_x, input_data[i].m_y, input_data[i].m_z,
4161                                          input_data[i].m_w);
4162                 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
4163         }
4164
4165         /* Execute draw call with transform feedback */
4166         gl.beginTransformFeedback(GL_POINTS);
4167         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
4168
4169         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
4170         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
4171
4172         gl.endTransformFeedback();
4173         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
4174
4175         /* Capture results */
4176         GLvoid* feedback_data = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
4177         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
4178
4179         GLfloat* float_ptr = (GLfloat*)feedback_data;
4180
4181         /* First result */
4182         out_first_routine_result.m_x = float_ptr[0];
4183         out_first_routine_result.m_y = float_ptr[1];
4184         out_first_routine_result.m_z = float_ptr[2];
4185         out_first_routine_result.m_w = float_ptr[3];
4186
4187         /* Second result */
4188         out_second_routine_result.m_x = float_ptr[4];
4189         out_second_routine_result.m_y = float_ptr[5];
4190         out_second_routine_result.m_z = float_ptr[6];
4191         out_second_routine_result.m_w = float_ptr[7];
4192
4193         /* Third result */
4194         out_third_routine_result.m_x = float_ptr[8];
4195         out_third_routine_result.m_y = float_ptr[9];
4196         out_third_routine_result.m_z = float_ptr[10];
4197         out_third_routine_result.m_w = float_ptr[11];
4198
4199         /* Fourth result */
4200         GLuint* uint_ptr                          = (GLuint*)(float_ptr + 12);
4201         out_fourth_routine_result.m_x = uint_ptr[0];
4202         out_fourth_routine_result.m_y = uint_ptr[1];
4203         out_fourth_routine_result.m_z = uint_ptr[2];
4204         out_fourth_routine_result.m_w = uint_ptr[3];
4205
4206         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
4207         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
4208 }
4209
4210 /** Verify if results match expected results
4211  *
4212  * @param first_routine_result           Result of first routine
4213  * @param second_routine_result          Result of second routine
4214  * @param third_routine_result           Result of third routine
4215  * @param fourth_routine_result          Result of fourth routine
4216  * @param first_routine_expected_result  Expected result of first routine
4217  * @param second_routine_expected_result Expected result of second routine
4218  * @param third_routine_expected_result  Expected result of third routine
4219  * @param fourth_routine_expected_result Expected result of fourth routine
4220  **/
4221 bool FunctionalTest5::verify(const Utils::vec4<glw::GLfloat>& first_routine_result,
4222                                                          const Utils::vec4<glw::GLfloat>& second_routine_result,
4223                                                          const Utils::vec4<glw::GLfloat>& third_routine_result,
4224                                                          const Utils::vec4<glw::GLuint>&  fourth_routine_result,
4225                                                          const Utils::vec4<glw::GLfloat>& first_routine_expected_result,
4226                                                          const Utils::vec4<glw::GLfloat>& second_routine_expected_result,
4227                                                          const Utils::vec4<glw::GLfloat>& third_routine_expected_result,
4228                                                          const Utils::vec4<glw::GLuint>&  fourth_routine_expected_result) const
4229 {
4230         bool result = true;
4231
4232         result = result && (first_routine_result == first_routine_expected_result);
4233         result = result && (second_routine_result == second_routine_expected_result);
4234         result = result && (third_routine_result == third_routine_expected_result);
4235         result = result && (fourth_routine_result == fourth_routine_expected_result);
4236
4237         return result;
4238 }
4239
4240 /** Constructor
4241  *
4242  * @param context CTS context
4243  **/
4244 FunctionalTest6::FunctionalTest6(deqp::Context& context)
4245         : TestCase(context, "static_subroutine_call", "Verify that subroutine can be called in a static manner")
4246 {
4247 }
4248
4249 /** Execute test
4250  *
4251  * @return tcu::TestNode::STOP
4252  **/
4253 tcu::TestNode::IterateResult FunctionalTest6::iterate()
4254 {
4255         static const GLchar* vertex_shader_code = "#version 400 core\n"
4256                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
4257                                                                                           "\n"
4258                                                                                           "precision highp float;\n"
4259                                                                                           "\n"
4260                                                                                           "// Subroutine type\n"
4261                                                                                           "subroutine vec4 routine_type(in vec4 iparam);\n"
4262                                                                                           "\n"
4263                                                                                           "// Subroutine definition\n"
4264                                                                                           "subroutine(routine_type) vec4 square(in vec4 iparam)\n"
4265                                                                                           "{\n"
4266                                                                                           "    return iparam * iparam;\n"
4267                                                                                           "}\n"
4268                                                                                           "\n"
4269                                                                                           "// Sub routine uniform\n"
4270                                                                                           "subroutine uniform routine_type routine;\n"
4271                                                                                           "\n"
4272                                                                                           "// Input data\n"
4273                                                                                           "uniform vec4 input_data;\n"
4274                                                                                           "\n"
4275                                                                                           "// Output\n"
4276                                                                                           "out  vec4 out_result;\n"
4277                                                                                           "\n"
4278                                                                                           "void main()\n"
4279                                                                                           "{\n"
4280                                                                                           "    out_result  = square(input_data);\n"
4281                                                                                           "}\n"
4282                                                                                           "\n";
4283
4284         static const GLchar* varying_name = "out_result";
4285
4286         /* Test data */
4287         static const Utils::vec4<GLfloat> input_data(1.0f, 4.0f, 9.0f, 16.0f);
4288
4289         static const Utils::vec4<GLfloat> expected_result(1.0f, 16.0f, 81.0f, 256.0f);
4290
4291         static const GLuint transform_feedback_buffer_size = 4 * sizeof(GLfloat);
4292
4293         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
4294         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
4295         {
4296                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
4297         }
4298
4299         /* GL objects */
4300         Utils::program   program(m_context);
4301         Utils::buffer     transform_feedback_buffer(m_context);
4302         Utils::vertexArray vao(m_context);
4303
4304         /* Init GL objects */
4305         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name,
4306                                   1 /* n_varyings */);
4307
4308         program.use();
4309
4310         vao.generate();
4311         vao.bind();
4312
4313         transform_feedback_buffer.generate();
4314         transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
4315                                                                          GL_DYNAMIC_COPY);
4316         transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
4317
4318         /* Test */
4319         {
4320                 const glw::Functions& gl                           = m_context.getRenderContext().getFunctions();
4321                 const GLint                       uniform_location = gl.getUniformLocation(program.m_program_object_id, "input_data");
4322
4323                 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation");
4324
4325                 if (-1 == uniform_location)
4326                 {
4327                         TCU_FAIL("Uniform is not available");
4328                 }
4329
4330                 /* Set up input data uniforms */
4331                 gl.uniform4f(uniform_location, input_data.m_x, input_data.m_y, input_data.m_z, input_data.m_w);
4332                 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
4333
4334                 /* Execute draw call with transform feedback */
4335                 gl.beginTransformFeedback(GL_POINTS);
4336                 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
4337
4338                 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
4339                 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
4340
4341                 gl.endTransformFeedback();
4342                 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
4343
4344                 /* Capture results */
4345                 GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
4346                 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
4347
4348                 Utils::vec4<GLfloat> result(feedback_data[0], feedback_data[1], feedback_data[2], feedback_data[3]);
4349
4350                 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
4351                 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
4352
4353                 /* Verify */
4354                 if (expected_result == result)
4355                 {
4356                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
4357                 }
4358                 else
4359                 {
4360                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
4361                                                                                                 << tcu::TestLog::EndMessage;
4362
4363                         tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4364
4365                         message << "Function: square( ";
4366                         input_data.log(message);
4367                         message << " ). Result: ";
4368                         result.log(message);
4369                         message << ". Expected: ";
4370                         expected_result.log(message);
4371
4372                         message << tcu::TestLog::EndMessage;
4373
4374                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
4375                 }
4376         }
4377
4378         /* Done */
4379         return tcu::TestNode::STOP;
4380 }
4381
4382 /** Constructor
4383  *
4384  * @param context CTS context
4385  **/
4386 FunctionalTest7_8::FunctionalTest7_8(deqp::Context& context)
4387         : TestCase(context, "arrayed_subroutine_uniforms", "Verify that subroutine can be called in a static manner")
4388 {
4389 }
4390
4391 /** Execute test
4392  *
4393  * @return tcu::TestNode::STOP
4394  **/
4395 tcu::TestNode::IterateResult FunctionalTest7_8::iterate()
4396 {
4397         static const GLchar* vertex_shader_code =
4398                 "#version 400 core\n"
4399                 "#extension GL_ARB_shader_subroutine : require\n"
4400                 "\n"
4401                 "precision highp float;\n"
4402                 "\n"
4403                 "// Subroutine type\n"
4404                 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
4405                 "\n"
4406                 "// Subroutine definitions\n"
4407                 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
4408                 "{\n"
4409                 "    return left + right;\n"
4410                 "}\n"
4411                 "\n"
4412                 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
4413                 "{\n"
4414                 "    return left * right;\n"
4415                 "}\n"
4416                 "\n"
4417                 "// Sub routine uniform\n"
4418                 "subroutine uniform routine_type routine[4];\n"
4419                 "\n"
4420                 "// Input data\n"
4421                 "uniform vec4  uni_left;\n"
4422                 "uniform vec4  uni_right;\n"
4423                 "uniform uvec4 uni_indices;\n"
4424                 "\n"
4425                 "// Output\n"
4426                 "out vec4 out_combined;\n"
4427                 "out vec4 out_combined_inverted;\n"
4428                 "out vec4 out_constant;\n"
4429                 "out vec4 out_constant_inverted;\n"
4430                 "out vec4 out_dynamic;\n"
4431                 "out vec4 out_dynamic_inverted;\n"
4432                 "out vec4 out_loop;\n"
4433                 "out uint out_array_length;\n"
4434                 "\n"
4435                 "void main()\n"
4436                 "{\n"
4437                 "    out_combined          = routine[3](routine[2](routine[1](routine[0](uni_left, uni_right), uni_right), "
4438                 "uni_right), uni_right);\n"
4439                 "    out_combined_inverted = routine[0](routine[1](routine[2](routine[3](uni_left, uni_right), uni_right), "
4440                 "uni_right), uni_right);\n"
4441                 "    \n"
4442                 "    out_constant          = routine[3](routine[2](routine[1](routine[0](vec4(1, 2, 3, 4), vec4(-5, -6, -7, "
4443                 "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n"
4444                 "    out_constant_inverted = routine[0](routine[1](routine[2](routine[3](vec4(1, 2, 3, 4), vec4(-5, -6, -7, "
4445                 "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n"
4446                 "    \n"
4447                 "    out_dynamic           = "
4448                 "routine[uni_indices.w](routine[uni_indices.z](routine[uni_indices.y](routine[uni_indices.x](uni_left, "
4449                 "uni_right), uni_right), uni_right), uni_right);\n"
4450                 "    out_dynamic_inverted  = "
4451                 "routine[uni_indices.x](routine[uni_indices.y](routine[uni_indices.z](routine[uni_indices.w](uni_left, "
4452                 "uni_right), uni_right), uni_right), uni_right);\n"
4453                 "    \n"
4454                 "    out_loop              = uni_left;\n"
4455                 "    for (uint i = 0u; i < routine.length(); ++i)\n"
4456                 "    {\n"
4457                 "        out_loop          = routine[i](out_loop, uni_right);\n"
4458                 "    }\n"
4459                 "    \n"
4460                 "    out_array_length      = routine.length() + 6 - (uni_indices.x + uni_indices.y + uni_indices.z + "
4461                 "uni_indices.w);\n"
4462                 "}\n"
4463                 "\n";
4464
4465         static const GLchar* subroutine_names[] = {
4466                 "add", "multiply",
4467         };
4468         static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
4469
4470         static const GLchar* subroutine_uniform_names[] = { "routine[0]", "routine[1]", "routine[2]", "routine[3]" };
4471         static const GLuint  n_subroutine_uniform_names =
4472                 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]);
4473
4474         static const GLchar* uniform_names[] = {
4475                 "uni_left", "uni_right", "uni_indices",
4476         };
4477         static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]);
4478
4479         static const GLchar* varying_names[] = { "out_combined", "out_combined_inverted",
4480                                                                                          "out_constant", "out_constant_inverted",
4481                                                                                          "out_dynamic",  "out_dynamic_inverted",
4482                                                                                          "out_loop",     "out_array_length" };
4483
4484         static const GLuint n_varyings                                     = sizeof(varying_names) / sizeof(varying_names[0]);
4485         static const GLuint transform_feedback_buffer_size = n_varyings * 4 * sizeof(GLfloat);
4486
4487         /* Test data */
4488         static const Utils::vec4<GLfloat> uni_left(-1.0f, 0.75f, -0.5f, 0.25f);
4489         static const Utils::vec4<GLfloat> uni_right(1.0f, -0.75f, 0.5f, -0.25f);
4490         static const Utils::vec4<GLuint>  uni_indices(1, 2, 0, 3);
4491
4492         static const GLuint subroutine_combinations[][4] = {
4493                 { 0, 0, 0, 0 }, /* + + + + */
4494                 { 0, 0, 0, 1 }, /* + + + * */
4495                 { 0, 0, 1, 0 }, /* + + * + */
4496                 { 0, 0, 1, 1 }, /* + + * * */
4497                 { 0, 1, 0, 0 }, /* + * + + */
4498                 { 0, 1, 0, 1 }, /* + * + * */
4499                 { 0, 1, 1, 0 }, /* + * * + */
4500                 { 0, 1, 1, 1 }, /* + * * * */
4501                 { 1, 0, 0, 0 }, /* * + + + */
4502                 { 1, 0, 0, 1 }, /* * + + * */
4503                 { 1, 0, 1, 0 }, /* * + * + */
4504                 { 1, 0, 1, 1 }, /* * + * * */
4505                 { 1, 1, 0, 0 }, /* * * + + */
4506                 { 1, 1, 0, 1 }, /* * * + * */
4507                 { 1, 1, 1, 0 }, /* * * * + */
4508                 { 1, 1, 1, 1 }  /* * * * * */
4509         };
4510         static const GLuint n_subroutine_combinations =
4511                 sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]);
4512
4513         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
4514         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
4515         {
4516                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
4517         }
4518
4519         /* GL objects */
4520         Utils::program   program(m_context);
4521         Utils::buffer     transform_feedback_buffer(m_context);
4522         Utils::vertexArray vao(m_context);
4523
4524         bool result = true;
4525
4526         /* Init GL objects */
4527         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names,
4528                                   n_varyings);
4529
4530         program.use();
4531
4532         vao.generate();
4533         vao.bind();
4534
4535         transform_feedback_buffer.generate();
4536
4537         /* Get subroutine indices */
4538         for (GLuint routine = 0; routine < n_subroutine_names; ++routine)
4539         {
4540                 m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER);
4541         }
4542
4543         /* Get subroutine uniform locations */
4544         for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
4545         {
4546                 m_subroutine_uniform_locations[uniform] =
4547                         program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER);
4548         }
4549
4550         /* Get uniform locations */
4551         for (GLuint i = 0; i < n_uniform_names; ++i)
4552         {
4553                 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]);
4554         }
4555
4556         /* Test */
4557         for (GLuint i = 0; i < n_subroutine_combinations; ++i)
4558         {
4559                 /* Clean */
4560                 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
4561                                                                                  GL_DYNAMIC_COPY);
4562                 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
4563
4564                 /* Verify */
4565                 if (false == testDraw(subroutine_combinations[i], uni_left, uni_right, uni_indices))
4566                 {
4567                         result = false;
4568                 }
4569         }
4570
4571         if (true == result)
4572         {
4573                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
4574         }
4575         else
4576         {
4577                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
4578         }
4579
4580         /* Done */
4581         return tcu::TestNode::STOP;
4582 }
4583
4584 /* Calculate result of function applied to operands
4585  *
4586  * @param function Function id, 0 is sum, 1 is multiplication
4587  * @param left     Left operand
4588  * @param right    Right operand
4589  * @param out      Function result
4590  **/
4591 void FunctionalTest7_8::calculate(glw::GLuint function, const Utils::vec4<glw::GLfloat>& left,
4592                                                                   const Utils::vec4<glw::GLfloat>& right, Utils::vec4<glw::GLfloat>& out) const
4593 {
4594         if (0 == function)
4595         {
4596                 out.m_x = left.m_x + right.m_x;
4597                 out.m_y = left.m_y + right.m_y;
4598                 out.m_z = left.m_z + right.m_z;
4599                 out.m_w = left.m_w + right.m_w;
4600         }
4601         else
4602         {
4603                 out.m_x = left.m_x * right.m_x;
4604                 out.m_y = left.m_y * right.m_y;
4605                 out.m_z = left.m_z * right.m_z;
4606                 out.m_w = left.m_w * right.m_w;
4607         }
4608 }
4609
4610 /** Calculate expected values for all operations
4611  *
4612  * @param combination           Function combination, first applied function is at index [0]
4613  * @param left                  Left operand
4614  * @param right                 Right operand
4615  * @param indices               Indices used by dynamic calls
4616  * @param out_combined          Expected result of "combined" operation
4617  * @param out_combined_inverted Expected result of "combined_inverted" operation
4618  * @param out_constant          Expected result of "constant" operation
4619  * @param out_constant_inverted Expected result of "constant_inverted" operation
4620  * @param out_dynamic           Expected result of "dynamic" operation
4621  * @param out_dynamic_inverted  Expected result of "out_dynamic_inverted" operation
4622  * @param out_loop              Expected result of "loop" operation
4623  **/
4624 void FunctionalTest7_8::calculate(
4625         const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, const Utils::vec4<glw::GLfloat>& right,
4626         const Utils::vec4<glw::GLuint>& indices, Utils::vec4<glw::GLfloat>& out_combined,
4627         Utils::vec4<glw::GLfloat>& out_combined_inverted, Utils::vec4<glw::GLfloat>& out_constant,
4628         Utils::vec4<glw::GLfloat>& out_constant_inverted, Utils::vec4<glw::GLfloat>& out_dynamic,
4629         Utils::vec4<glw::GLfloat>& out_dynamic_inverted, Utils::vec4<glw::GLfloat>& out_loop) const
4630 {
4631         /* Indices used by "dynamic" operations, range <0..4> */
4632         const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y],
4633                                                                                         combination[indices.m_z], combination[indices.m_w] };
4634
4635         /* Values used by "constant" operations, come from shader code */
4636         const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4),
4637                                                                                                                   Utils::vec4<glw::GLfloat>(-5, -6, -7, -8),
4638                                                                                                                   Utils::vec4<glw::GLfloat>(-1, -2, -3, -4),
4639                                                                                                                   Utils::vec4<glw::GLfloat>(5, 6, 7, 8),
4640                                                                                                                   Utils::vec4<glw::GLfloat>(1, 2, 3, 4) };
4641
4642         /* Start values */
4643         Utils::vec4<glw::GLfloat> combined                      = left;
4644         Utils::vec4<glw::GLfloat> combined_inverted = left;
4645         Utils::vec4<glw::GLfloat> constant                      = constant_values[0];
4646         Utils::vec4<glw::GLfloat> constant_inverted = constant_values[0];
4647         Utils::vec4<glw::GLfloat> dynamic                       = left;
4648         Utils::vec4<glw::GLfloat> dynamic_inverted  = left;
4649
4650         /* Calculate expected results */
4651         for (GLuint i = 0; i < 4; ++i)
4652         {
4653                 GLuint function                                  = combination[i];
4654                 GLuint function_inverted                 = combination[3 - i];
4655                 GLuint dynamic_function                  = dynamic_combination[i];
4656                 GLuint dynamic_function_inverted = dynamic_combination[3 - i];
4657
4658                 calculate(function, combined, right, combined);
4659                 calculate(function_inverted, combined_inverted, right, combined_inverted);
4660                 calculate(function, constant, constant_values[i + 1], constant);
4661                 calculate(function_inverted, constant_inverted, constant_values[i + 1], constant_inverted);
4662                 calculate(dynamic_function, dynamic, right, dynamic);
4663                 calculate(dynamic_function_inverted, dynamic_inverted, right, dynamic_inverted);
4664         }
4665
4666         /* Store results */
4667         out_combined              = combined;
4668         out_combined_inverted = combined_inverted;
4669         out_constant              = constant;
4670         out_constant_inverted = constant_inverted;
4671         out_dynamic                       = dynamic;
4672         out_dynamic_inverted  = dynamic_inverted;
4673         out_loop                          = combined;
4674 }
4675
4676 /** Log error
4677  *
4678  * @param combination   Operations combination
4679  * @param left          Left operand
4680  * @param right         Right operand
4681  * @param indices       Inidices used by "dynamic" calls
4682  * @param vec4_expected Expected results
4683  * @param vec4_result   Results
4684  * @param array_length  Length of array
4685  * @param result        Comparison results
4686  **/
4687 void FunctionalTest7_8::logError(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left,
4688                                                                  const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices,
4689                                                                  const Utils::vec4<glw::GLfloat> vec4_expected[7],
4690                                                                  const Utils::vec4<glw::GLfloat> vec4_result[7], glw::GLuint array_length,
4691                                                                  bool result[7]) const
4692 {
4693         static const GLuint n_functions  = 4;
4694         static const GLuint n_operations = 7;
4695
4696         /* Indices used by "dynamic" operations, range <0..4> */
4697         const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y],
4698                                                                                         combination[indices.m_z], combination[indices.m_w] };
4699
4700         /* Function symbols */
4701         GLchar functions[4];
4702         GLchar functions_inverted[4];
4703         GLchar functions_dynamic[4];
4704         GLchar functions_dynamic_inverted[4];
4705
4706         for (GLuint i = 0; i < n_functions; ++i)
4707         {
4708                 GLchar function                 = (0 == combination[i]) ? '+' : '*';
4709                 GLchar dynamic_function = (0 == dynamic_combination[i]) ? '+' : '*';
4710
4711                 functions[i]                                                                    = function;
4712                 functions_inverted[n_functions - i - 1]                 = function;
4713                 functions_dynamic[i]                                                    = dynamic_function;
4714                 functions_dynamic_inverted[n_functions - i - 1] = dynamic_function;
4715         }
4716
4717         /* Values used by "constant" operations, come from shader code */
4718         const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4),
4719                                                                                                                   Utils::vec4<glw::GLfloat>(-5, -6, -7, -8),
4720                                                                                                                   Utils::vec4<glw::GLfloat>(-1, -2, -3, -4),
4721                                                                                                                   Utils::vec4<glw::GLfloat>(5, 6, 7, 8),
4722                                                                                                                   Utils::vec4<glw::GLfloat>(1, 2, 3, 4) };
4723
4724         /* Values used by non-"constant" operations */
4725         Utils::vec4<glw::GLfloat> dynamic_values[5];
4726         dynamic_values[0] = left;
4727         dynamic_values[1] = right;
4728         dynamic_values[2] = right;
4729         dynamic_values[3] = right;
4730         dynamic_values[4] = right;
4731
4732         /* For each operation */
4733         for (GLuint i = 0; i < n_operations; ++i)
4734         {
4735                 /* If result is failure */
4736                 if (false == result[i])
4737                 {
4738                         const GLchar*                                    description = 0;
4739                         const Utils::vec4<glw::GLfloat>* input           = 0;
4740                         const GLchar*                                    operation   = 0;
4741
4742                         switch (i)
4743                         {
4744                         case 0:
4745                                 description = "Call made with predefined array indices";
4746                                 input           = dynamic_values;
4747                                 operation   = functions;
4748                                 break;
4749                         case 1:
4750                                 description = "Call made with predefined array indices in inverted order";
4751                                 input           = dynamic_values;
4752                                 operation   = functions_inverted;
4753                                 break;
4754                         case 2:
4755                                 description = "Call made with predefined array indices, for constant values";
4756                                 input           = constant_values;
4757                                 operation   = functions;
4758                                 break;
4759                         case 3:
4760                                 description = "Call made with predefined array indices in inverted order, for constant values";
4761                                 input           = constant_values;
4762                                 operation   = functions_inverted;
4763                                 break;
4764                         case 4:
4765                                 description = "Call made with dynamic array indices";
4766                                 input           = dynamic_values;
4767                                 operation   = functions_dynamic;
4768                                 break;
4769                         case 5:
4770                                 description = "Call made with dynamic array indices in inverted order";
4771                                 input           = dynamic_values;
4772                                 operation   = functions_dynamic_inverted;
4773                                 break;
4774                         case 6:
4775                                 description = "Call made with loop";
4776                                 input           = dynamic_values;
4777                                 operation   = functions;
4778                                 break;
4779                         }
4780
4781                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
4782                                                                                                 << tcu::TestLog::EndMessage;
4783
4784                         m_context.getTestContext().getLog() << tcu::TestLog::Message << description << tcu::TestLog::EndMessage;
4785
4786                         tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4787
4788                         message << "Operation: ((((";
4789                         input[0].log(message);
4790                         for (GLuint function = 0; function < n_functions; ++function)
4791                         {
4792                                 message << " " << operation[function] << " ";
4793
4794                                 input[function + 1].log(message);
4795
4796                                 message << ")";
4797                         }
4798
4799                         message << tcu::TestLog::EndMessage;
4800
4801                         message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4802
4803                         message << "Result: ";
4804                         vec4_result[i].log(message);
4805
4806                         message << tcu::TestLog::EndMessage;
4807
4808                         message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
4809
4810                         message << "Expected: ";
4811                         vec4_expected[i].log(message);
4812
4813                         message << tcu::TestLog::EndMessage;
4814                 }
4815
4816                 /* Check array length, it should be 4 */
4817                 if (4 != array_length)
4818                 {
4819                         m_context.getTestContext().getLog() << tcu::TestLog::Message
4820                                                                                                 << "Error. Invalid array length: " << array_length << ". Expected 4."
4821                                                                                                 << tcu::TestLog::EndMessage;
4822                 }
4823         }
4824 }
4825
4826 /** Execute draw call and verifies captrued varyings
4827  *
4828  * @param combination           Function combination, first applied function is at index [0]
4829  * @param left                  Left operand
4830  * @param right                 Right operand
4831  * @param indices               Indices used by dynamic calls
4832  *
4833  * @return true if all results match expected values, false otherwise
4834  **/
4835 bool FunctionalTest7_8::testDraw(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left,
4836                                                                  const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices) const
4837 {
4838         const glw::Functions& gl                          = m_context.getRenderContext().getFunctions();
4839         static const GLuint   n_vec4_varyings = 7;
4840         bool                              result                  = true;
4841         GLuint                            subroutine_indices[4];
4842         static const GLuint   n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]);
4843
4844         /* Prepare expected results */
4845         Utils::vec4<glw::GLfloat> expected_results[7];
4846         calculate(combination, left, right, indices, expected_results[0], expected_results[1], expected_results[2],
4847                           expected_results[3], expected_results[4], expected_results[5], expected_results[6]);
4848
4849         /* Set up input data uniforms */
4850         gl.uniform4f(m_uniform_locations[0], left.m_x, left.m_y, left.m_z, left.m_w);
4851         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
4852
4853         gl.uniform4f(m_uniform_locations[1], right.m_x, right.m_y, right.m_z, right.m_w);
4854         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
4855
4856         gl.uniform4ui(m_uniform_locations[2], indices.m_x, indices.m_y, indices.m_z, indices.m_w);
4857         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4ui");
4858
4859         /* Prepare subroutine uniform data */
4860         for (GLuint i = 0; i < n_subroutine_uniforms; ++i)
4861         {
4862                 const GLuint location = m_subroutine_uniform_locations[i];
4863
4864                 subroutine_indices[location] = m_subroutine_indices[combination[i]];
4865         }
4866
4867         /* Set up subroutine uniforms */
4868         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]);
4869         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
4870
4871         /* Execute draw call with transform feedback */
4872         gl.beginTransformFeedback(GL_POINTS);
4873         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
4874
4875         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
4876         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
4877
4878         gl.endTransformFeedback();
4879         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
4880
4881         /* Capture results */
4882         GLvoid* feedback_data = (GLvoid*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
4883         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
4884
4885         Utils::vec4<GLfloat> vec4_results[7];
4886         bool                             results[7];
4887         GLfloat*                         float_data = (GLfloat*)feedback_data;
4888         for (GLuint i = 0; i < n_vec4_varyings; ++i)
4889         {
4890                 vec4_results[i].m_x = float_data[i * 4 + 0];
4891                 vec4_results[i].m_y = float_data[i * 4 + 1];
4892                 vec4_results[i].m_z = float_data[i * 4 + 2];
4893                 vec4_results[i].m_w = float_data[i * 4 + 3];
4894         }
4895
4896         GLuint* uint_data       = (GLuint*)(float_data + (n_vec4_varyings)*4);
4897         GLuint  array_length = uint_data[0];
4898
4899         /* Unmap buffer */
4900         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
4901         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
4902
4903         /* Verification */
4904         for (GLuint i = 0; i < n_vec4_varyings; ++i)
4905         {
4906                 results[i] = (vec4_results[i] == expected_results[i]);
4907                 result   = result && results[i];
4908         }
4909
4910         result = result && (4 == array_length);
4911
4912         /* Log error if any */
4913         if (false == result)
4914         {
4915                 logError(combination, left, right, indices, expected_results, vec4_results, array_length, results);
4916         }
4917
4918         /* Done */
4919         return result;
4920 }
4921
4922 /** Constructor.
4923  *
4924  *  @param context Rendering context.
4925  *
4926  **/
4927 FunctionalTest9::FunctionalTest9(deqp::Context& context)
4928         : TestCase(context, "subroutines_3_subroutine_types_and_subroutine_uniforms_one_function",
4929                            "Makes sure that program with one function associated with 3 different "
4930                            "subroutine types and 3 subroutine uniforms using that function compiles "
4931                            "and works as expected")
4932         , m_has_test_passed(true)
4933         , m_n_points_to_draw(16) /* arbitrary value */
4934         , m_po_id(0)
4935         , m_vao_id(0)
4936         , m_vs_id(0)
4937         , m_xfb_bo_id(0)
4938 {
4939         /* Left blank intentionally */
4940 }
4941
4942 /** De-initializes GL objects that may have been created during test execution. */
4943 void FunctionalTest9::deinit()
4944 {
4945         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
4946
4947         if (m_po_id != 0)
4948         {
4949                 gl.deleteProgram(m_po_id);
4950
4951                 m_po_id = 0;
4952         }
4953
4954         if (m_vao_id != 0)
4955         {
4956                 gl.deleteVertexArrays(1, &m_vao_id);
4957
4958                 m_vao_id = 0;
4959         }
4960
4961         if (m_vs_id != 0)
4962         {
4963                 gl.deleteShader(m_vs_id);
4964
4965                 m_vs_id = 0;
4966         }
4967
4968         if (m_xfb_bo_id != 0)
4969         {
4970                 gl.deleteBuffers(1, &m_xfb_bo_id);
4971
4972                 m_xfb_bo_id = 0;
4973         }
4974 }
4975
4976 /** Retrieves body of a vertex shader that should be used
4977  *  for the testing purposes.
4978  **/
4979 std::string FunctionalTest9::getVertexShaderBody() const
4980 {
4981         return "#version 400\n"
4982                    "\n"
4983                    "#extension GL_ARB_shader_subroutine : require\n"
4984                    "\n"
4985                    "subroutine void subroutineType1(inout float);\n"
4986                    "subroutine void subroutineType2(inout float);\n"
4987                    "subroutine void subroutineType3(inout float);\n"
4988                    "\n"
4989                    "subroutine(subroutineType1, subroutineType2, subroutineType3) void function(inout float result)\n"
4990                    "{\n"
4991                    "    result += float(0.123) + float(gl_VertexID);\n"
4992                    "}\n"
4993                    "\n"
4994                    "subroutine uniform subroutineType1 subroutine_uniform1;\n"
4995                    "subroutine uniform subroutineType2 subroutine_uniform2;\n"
4996                    "subroutine uniform subroutineType3 subroutine_uniform3;\n"
4997                    "\n"
4998                    "out vec4 result;\n"
4999                    "\n"
5000                    "void main()\n"
5001                    "{\n"
5002                    "    result = vec4(0, 1, 2, 3);\n"
5003                    "\n"
5004                    "    subroutine_uniform1(result.x);\n"
5005                    "    subroutine_uniform2(result.y);\n"
5006                    "    subroutine_uniform3(result.z);\n"
5007                    "\n"
5008                    "    result.w += result.x + result.y + result.z;\n"
5009                    "}\n";
5010 }
5011
5012 /** Initializes all GL objects required to run the test. */
5013 void FunctionalTest9::initTest()
5014 {
5015         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
5016
5017         /* Set up program object */
5018         const char* xfb_varyings[] = { "result" };
5019
5020         const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]);
5021         if (!Utils::buildProgram(gl, getVertexShaderBody(), "",                                   /* tc_body */
5022                                                          "",                                                                                      /* te_body */
5023                                                          "",                                                                                      /* gs_body */
5024                                                          "",                                                                                      /* fs_body */
5025                                                          xfb_varyings, n_xfb_varyings, &m_vs_id, DE_NULL, /* out_tc_id */
5026                                                          DE_NULL,                                                                                 /* out_te_id */
5027                                                          DE_NULL,                                                                                 /* out_gs_id */
5028                                                          DE_NULL,                                                                                 /* out_fs_id */
5029                                                          &m_po_id))
5030         {
5031                 TCU_FAIL("Program failed to link successfully");
5032         }
5033
5034         /* Set up a buffer object we will use to hold XFB data */
5035         const unsigned int xfb_bo_size = static_cast<unsigned int>(sizeof(float) * 4 /* components */ * m_n_points_to_draw);
5036
5037         gl.genBuffers(1, &m_xfb_bo_id);
5038         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");
5039
5040         gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id);
5041         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");
5042
5043         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id);
5044         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");
5045
5046         gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_bo_size, DE_NULL, /* data */
5047                                   GL_STATIC_COPY);
5048         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");
5049
5050         /* Generate & bind a VAO */
5051         gl.genVertexArrays(1, &m_vao_id);
5052         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
5053
5054         gl.bindVertexArray(m_vao_id);
5055         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
5056 }
5057
5058 /** Executes test iteration.
5059  *
5060  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
5061  */
5062 tcu::TestNode::IterateResult FunctionalTest9::iterate()
5063 {
5064         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
5065
5066         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
5067         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
5068         {
5069                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
5070         }
5071         initTest();
5072
5073         /* Issue a draw call to make use of the three subroutine uniforms that we've defined */
5074         gl.useProgram(m_po_id);
5075         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
5076
5077         gl.beginTransformFeedback(GL_POINTS);
5078         GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");
5079         {
5080                 gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw);
5081                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
5082         }
5083         gl.endTransformFeedback();
5084         GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");
5085
5086         /* Map the XFB BO storage into process space */
5087         const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
5088         GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed.");
5089
5090         verifyXFBData(xfb_data_ptr);
5091
5092         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
5093         GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");
5094
5095         /* All done */
5096         if (m_has_test_passed)
5097         {
5098                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
5099         }
5100         else
5101         {
5102                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
5103         }
5104
5105         return STOP;
5106 }
5107
5108 /** Verifies the data XFBed out by the vertex shader. Should the data
5109  *  be found invalid, m_has_test_passed will be set to false.
5110  *
5111  *  @param data_ptr XFB data.
5112  **/
5113 void FunctionalTest9::verifyXFBData(const glw::GLvoid* data_ptr)
5114 {
5115         const float                     epsilon                 = 1e-5f;
5116         bool                            should_continue = true;
5117         const glw::GLfloat* traveller_ptr   = (const glw::GLfloat*)data_ptr;
5118
5119         for (unsigned int n_point = 0; n_point < m_n_points_to_draw && should_continue; ++n_point)
5120         {
5121                 tcu::Vec4 expected_result(0, 1, 2, 3);
5122
5123                 for (unsigned int n_component = 0; n_component < 3 /* xyz */; ++n_component)
5124                 {
5125                         expected_result[n_component] += 0.123f + float(n_point);
5126                 }
5127
5128                 expected_result[3 /* w */] += expected_result[0] + expected_result[1] + expected_result[2];
5129
5130                 if (de::abs(expected_result[0] - traveller_ptr[0]) > epsilon ||
5131                         de::abs(expected_result[1] - traveller_ptr[1]) > epsilon ||
5132                         de::abs(expected_result[2] - traveller_ptr[2]) > epsilon ||
5133                         de::abs(expected_result[3] - traveller_ptr[3]) > epsilon)
5134                 {
5135                         m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data is invalid. Expected:"
5136                                                                                                                    "("
5137                                                            << expected_result[0] << ", " << expected_result[1] << ", " << expected_result[2] << ", "
5138                                                            << expected_result[3] << "), found:(" << traveller_ptr[0] << ", " << traveller_ptr[1]
5139                                                            << ", " << traveller_ptr[2] << ", " << traveller_ptr[3] << ")."
5140                                                            << tcu::TestLog::EndMessage;
5141
5142                         m_has_test_passed = false;
5143                         should_continue   = false;
5144                 }
5145
5146                 traveller_ptr += 4; /* xyzw */
5147         }                                               /* for (all rendered points) */
5148 }
5149
5150 /** Constructor
5151  *
5152  * @param context CTS context
5153  **/
5154 FunctionalTest10::FunctionalTest10(deqp::Context& context)
5155         : TestCase(context, "arrays_of_arrays_of_uniforms", "Verify that arrays of arrays of uniforms works as expected")
5156 {
5157 }
5158
5159 /** Execute test
5160  *
5161  * @return tcu::TestNode::STOP
5162  **/
5163 tcu::TestNode::IterateResult FunctionalTest10::iterate()
5164 {
5165         static const GLchar* vertex_shader_code = "#version 400 core\n"
5166                                                                                           "#extension GL_ARB_arrays_of_arrays  : require\n"
5167                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
5168                                                                                           "\n"
5169                                                                                           "precision highp float;\n"
5170                                                                                           "\n"
5171                                                                                           "// Subroutine type\n"
5172                                                                                           "subroutine int routine_type(in int iparam);\n"
5173                                                                                           "\n"
5174                                                                                           "// Subroutine definitions\n"
5175                                                                                           "subroutine(routine_type) int increment(in int iparam)\n"
5176                                                                                           "{\n"
5177                                                                                           "    return iparam + 1;\n"
5178                                                                                           "}\n"
5179                                                                                           "\n"
5180                                                                                           "subroutine(routine_type) int decrement(in int iparam)\n"
5181                                                                                           "{\n"
5182                                                                                           "    return iparam - 1;\n"
5183                                                                                           "}\n"
5184                                                                                           "\n"
5185                                                                                           "// Sub routine uniform\n"
5186                                                                                           "subroutine uniform routine_type routine[4][4];\n"
5187                                                                                           "\n"
5188                                                                                           "// Output\n"
5189                                                                                           "out int out_result;\n"
5190                                                                                           "\n"
5191                                                                                           "void main()\n"
5192                                                                                           "{\n"
5193                                                                                           "    int result = 0;\n"
5194                                                                                           "    \n"
5195                                                                                           "    for (uint j = 0; j < routine.length(); ++j)\n"
5196                                                                                           "    {\n"
5197                                                                                           "        for (uint i = 0; i < routine[j].length(); ++i)\n"
5198                                                                                           "        {\n"
5199                                                                                           "            result = routine[j][i](result);\n"
5200                                                                                           "        }\n"
5201                                                                                           "    }\n"
5202                                                                                           "    \n"
5203                                                                                           "    out_result = result;\n"
5204                                                                                           "}\n"
5205                                                                                           "\n";
5206
5207         static const GLchar* subroutine_names[] = {
5208                 "increment", "decrement",
5209         };
5210         static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
5211
5212         static const GLchar* subroutine_uniform_names[] = {
5213                 "routine[0][0]", "routine[1][0]", "routine[2][0]", "routine[3][0]", "routine[0][1]", "routine[1][1]",
5214                 "routine[2][1]", "routine[3][1]", "routine[0][2]", "routine[1][2]", "routine[2][2]", "routine[3][2]",
5215                 "routine[0][3]", "routine[1][3]", "routine[2][3]", "routine[3][3]"
5216         };
5217         static const GLuint n_subroutine_uniform_names =
5218                 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]);
5219
5220         static const GLchar* varying_name                                       = "out_result";
5221         static const GLuint  transform_feedback_buffer_size = sizeof(GLint);
5222
5223         static const GLuint configuration_increment[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
5224
5225         static const GLuint configuration_decrement[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
5226
5227         static const GLuint configuration_mix[16] = { 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1 };
5228
5229         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
5230         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
5231         {
5232                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
5233         }
5234
5235         /* Do not execute the test if GL_ARB_arrays_of_arrays is not supported */
5236         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_arrays_of_arrays"))
5237         {
5238                 throw tcu::NotSupportedError("GL_ARB_arrays_of_arrays is not supported.");
5239         }
5240
5241         bool result = true;
5242
5243         /* GL objects */
5244         Utils::program   program(m_context);
5245         Utils::buffer     transform_feedback_buffer(m_context);
5246         Utils::vertexArray vao(m_context);
5247
5248         /* Init GL objects */
5249         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name,
5250                                   1 /* n_varyings */);
5251
5252         program.use();
5253
5254         vao.generate();
5255         vao.bind();
5256
5257         transform_feedback_buffer.generate();
5258         transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
5259                                                                          GL_DYNAMIC_COPY);
5260         transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
5261
5262         /* Get subroutine indices */
5263         for (GLuint routine = 0; routine < n_subroutine_names; ++routine)
5264         {
5265                 m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER);
5266         }
5267
5268         /* Get subroutine uniform locations */
5269         for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
5270         {
5271                 m_subroutine_uniform_locations[uniform] =
5272                         program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER);
5273         }
5274
5275         /* Test */
5276         GLint increment_result = testDraw(configuration_increment);
5277         GLint decrement_result = testDraw(configuration_decrement);
5278         GLint mix_result           = testDraw(configuration_mix);
5279
5280         /* Verify */
5281         if (16 != increment_result)
5282         {
5283                 result = false;
5284         }
5285
5286         if (-16 != decrement_result)
5287         {
5288                 result = false;
5289         }
5290         if (0 != mix_result)
5291         {
5292                 result = false;
5293         }
5294
5295         /* Set test result */
5296         if (true == result)
5297         {
5298                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
5299         }
5300         else
5301         {
5302                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
5303                                                                                         << " Incrementation applied 16 times: " << increment_result
5304                                                                                         << ". Decrementation applied 16 times: " << decrement_result
5305                                                                                         << ". Incrementation and decrementation applied 8 times: " << mix_result
5306                                                                                         << tcu::TestLog::EndMessage;
5307
5308                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
5309         }
5310
5311         /* Done */
5312         return tcu::TestNode::STOP;
5313 }
5314
5315 /** Execute draw call and return captured varying
5316  *
5317  * @param routine_indices Configuration of subroutine uniforms
5318  *
5319  * @return Value of varying captured with transform feedback
5320  **/
5321 GLint FunctionalTest10::testDraw(const GLuint routine_indices[16]) const
5322 {
5323         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
5324         GLuint                            subroutine_indices[16];
5325         static const GLuint   n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]);
5326
5327         /* Prepare subroutine uniform data */
5328         for (GLuint i = 0; i < n_subroutine_uniforms; ++i)
5329         {
5330                 const GLuint location = m_subroutine_uniform_locations[i];
5331
5332                 subroutine_indices[location] = m_subroutine_indices[routine_indices[i]];
5333         }
5334
5335         /* Set up subroutine uniforms */
5336         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]);
5337         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
5338
5339         /* Execute draw call with transform feedback */
5340         gl.beginTransformFeedback(GL_POINTS);
5341         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
5342
5343         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
5344         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
5345
5346         gl.endTransformFeedback();
5347         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
5348
5349         /* Capture results */
5350         GLint* feedback_data = (GLint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
5351         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
5352
5353         GLint result = feedback_data[0];
5354
5355         /* Unmap buffer */
5356         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
5357         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
5358
5359         return result;
5360 }
5361
5362 /* Definitions of constants used by FunctionalTest11 */
5363 const GLuint FunctionalTest11::m_texture_height = 32;
5364 const GLuint FunctionalTest11::m_texture_width  = 32;
5365
5366 /** Constructor
5367  *
5368  * @param context CTS context
5369  **/
5370 FunctionalTest11::FunctionalTest11(deqp::Context& context)
5371         : TestCase(context, "globals_sampling_output_discard_function_calls", "Verify that global variables, texture "
5372                                                                                                                                                   "sampling, fragment output, fragment discard "
5373                                                                                                                                                   "and function calls work as expected")
5374 {
5375 }
5376
5377 /** Execute test
5378  *
5379  * @return tcu::TestNode::STOP
5380  **/
5381 tcu::TestNode::IterateResult FunctionalTest11::iterate()
5382 {
5383         static const GLchar* fragment_shader_code =
5384                 "#version 400 core\n"
5385                 "#extension GL_ARB_shader_subroutine : require\n"
5386                 "\n"
5387                 "precision highp float;\n"
5388                 "\n"
5389                 "// Output\n"
5390                 "layout(location = 0) out vec4 out_color;\n"
5391                 "\n"
5392                 "// Global variables\n"
5393                 "vec4 success_color;\n"
5394                 "vec4 failure_color;\n"
5395                 "\n"
5396                 "// Samplers\n"
5397                 "uniform sampler2D sampler_1;\n"
5398                 "uniform sampler2D sampler_2;\n"
5399                 "\n"
5400                 "// Functions\n"
5401                 "bool are_same(in vec4 left, in vec4 right)\n"
5402                 "{\n"
5403                 "    bvec4 result;\n"
5404                 "\n"
5405                 "    result.x = (left.x == right.x);\n"
5406                 "    result.y = (left.y == right.y);\n"
5407                 "    result.z = (left.z == right.z);\n"
5408                 "    result.w = (left.w == right.w);\n"
5409                 "\n"
5410                 "    return all(result);\n"
5411                 "}\n"
5412                 "\n"
5413                 "bool are_different(in vec4 left, in vec4 right)\n"
5414                 "{\n"
5415                 "    bvec4 result;\n"
5416                 "\n"
5417                 "    result.x = (left.x != right.x);\n"
5418                 "    result.y = (left.y != right.y);\n"
5419                 "    result.z = (left.z != right.z);\n"
5420                 "    result.w = (left.w != right.w);\n"
5421                 "\n"
5422                 "    return any(result);\n"
5423                 "}\n"
5424                 "\n"
5425                 "// Subroutine types\n"
5426                 "subroutine void discard_fragment_type(void);\n"
5427                 "subroutine void set_global_colors_type(void);\n"
5428                 "subroutine vec4 sample_texture_type(in vec2);\n"
5429                 "subroutine bool comparison_type(in vec4 left, in vec4 right);\n"
5430                 "subroutine void test_type(void);\n"
5431                 "\n"
5432                 "// Subroutine definitions\n"
5433                 "// discard_fragment_type\n"
5434                 "subroutine(discard_fragment_type) void discard_yes(void)\n"
5435                 "{\n"
5436                 "    discard;\n"
5437                 "}\n"
5438                 "\n"
5439                 "subroutine(discard_fragment_type) void discard_no(void)\n"
5440                 "{\n"
5441                 "}\n"
5442                 "\n"
5443                 "// set_global_colors_type\n"
5444                 "subroutine(set_global_colors_type) void red_pass_blue_fail(void)\n"
5445                 "{\n"
5446                 "    success_color = vec4(1, 0, 0, 1);\n"
5447                 "    failure_color = vec4(0, 0, 1, 1);\n"
5448                 "}\n"
5449                 "\n"
5450                 "subroutine(set_global_colors_type) void blue_pass_red_fail(void)\n"
5451                 "{\n"
5452                 "    success_color = vec4(0, 0, 1, 1);\n"
5453                 "    failure_color = vec4(1, 0, 0, 1);\n"
5454                 "}\n"
5455                 "\n"
5456                 "// sample_texture_type\n"
5457                 "subroutine(sample_texture_type) vec4 first_sampler(in vec2 coord)\n"
5458                 "{\n"
5459                 "    return texture(sampler_1, coord);\n"
5460                 "}\n"
5461                 "\n"
5462                 "subroutine(sample_texture_type) vec4 second_sampler(in vec2 coord)\n"
5463                 "{\n"
5464                 "    return texture(sampler_2, coord);\n"
5465                 "}\n"
5466                 "\n"
5467                 "// comparison_type\n"
5468                 "subroutine(comparison_type) bool check_equal(in vec4 left, in vec4 right)\n"
5469                 "{\n"
5470                 "    return are_same(left, right);\n"
5471                 "}\n"
5472                 "\n"
5473                 "subroutine(comparison_type) bool check_not_equal(in vec4 left, in vec4 right)\n"
5474                 "{\n"
5475                 "    return are_different(left, right);\n"
5476                 "}\n"
5477                 "\n"
5478                 "// Subroutine uniforms\n"
5479                 "subroutine uniform discard_fragment_type  discard_fragment;\n"
5480                 "subroutine uniform set_global_colors_type set_global_colors;\n"
5481                 "subroutine uniform sample_texture_type    sample_texture;\n"
5482                 "subroutine uniform comparison_type        compare;\n"
5483                 "\n"
5484                 "// Subroutine definitions\n"
5485                 "// test_type\n"
5486                 "subroutine(test_type) void test_with_discard(void)\n"
5487                 "{\n"
5488                 "    discard_fragment();"
5489                 "\n"
5490                 "    out_color = failure_color;\n"
5491                 "\n"
5492                 "    set_global_colors();\n"
5493                 "\n"
5494                 "    vec4 sampled_color = sample_texture(gl_PointCoord);\n"
5495                 "\n"
5496                 "    bool comparison_result = compare(success_color, sampled_color);\n"
5497                 "\n"
5498                 "    if (true == comparison_result)\n"
5499                 "    {\n"
5500                 "        out_color = success_color;\n"
5501                 "    }\n"
5502                 "    else\n"
5503                 "    {\n"
5504                 "        out_color = failure_color;\n"
5505                 "    }\n"
5506                 "}\n"
5507                 "\n"
5508                 "subroutine(test_type) void test_without_discard(void)\n"
5509                 "{\n"
5510                 "    set_global_colors();\n"
5511                 "\n"
5512                 "    vec4 sampled_color = sample_texture(gl_PointCoord);\n"
5513                 "\n"
5514                 "    bool comparison_result = compare(success_color, sampled_color);\n"
5515                 "\n"
5516                 "    if (true == comparison_result)\n"
5517                 "    {\n"
5518                 "        out_color = success_color;\n"
5519                 "    }\n"
5520                 "    else\n"
5521                 "    {\n"
5522                 "        out_color = failure_color;\n"
5523                 "    }\n"
5524                 "}\n"
5525                 "\n"
5526                 "// Subroutine uniforms\n"
5527                 "subroutine uniform test_type test;\n"
5528                 "\n"
5529                 "void main()\n"
5530                 "{\n"
5531                 "    // Set colors\n"
5532                 "    success_color = vec4(0.5, 0.5, 0.5, 0.5);\n"
5533                 "    failure_color = vec4(0.5, 0.5, 0.5, 0.5);\n"
5534                 "\n"
5535                 "    test();\n"
5536                 "}\n"
5537                 "\n";
5538
5539         static const GLchar* geometry_shader_code = "#version 400 core\n"
5540                                                                                                 "#extension GL_ARB_shader_subroutine : require\n"
5541                                                                                                 "\n"
5542                                                                                                 "precision highp float;\n"
5543                                                                                                 "\n"
5544                                                                                                 "layout(points)                           in;\n"
5545                                                                                                 "layout(triangle_strip, max_vertices = 4) out;\n"
5546                                                                                                 "\n"
5547                                                                                                 "void main()\n"
5548                                                                                                 "{\n"
5549                                                                                                 "    gl_Position = vec4(-1, -1, 0, 1);\n"
5550                                                                                                 "    EmitVertex();\n"
5551                                                                                                 "    \n"
5552                                                                                                 "    gl_Position = vec4(-1,  1, 0, 1);\n"
5553                                                                                                 "    EmitVertex();\n"
5554                                                                                                 "    \n"
5555                                                                                                 "    gl_Position = vec4( 1, -1, 0, 1);\n"
5556                                                                                                 "    EmitVertex();\n"
5557                                                                                                 "    \n"
5558                                                                                                 "    gl_Position = vec4( 1,  1, 0, 1);\n"
5559                                                                                                 "    EmitVertex();\n"
5560                                                                                                 "    \n"
5561                                                                                                 "    EndPrimitive();\n"
5562                                                                                                 "}\n"
5563                                                                                                 "\n";
5564
5565         static const GLchar* vertex_shader_code = "#version 400 core\n"
5566                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
5567                                                                                           "\n"
5568                                                                                           "precision highp float;\n"
5569                                                                                           "\n"
5570                                                                                           "void main()\n"
5571                                                                                           "{\n"
5572                                                                                           "}\n"
5573                                                                                           "\n";
5574
5575         static const GLchar* subroutine_names[][2] = { { "discard_yes", "discard_no" },
5576                                                                                                    { "red_pass_blue_fail", "blue_pass_red_fail" },
5577                                                                                                    { "first_sampler", "second_sampler" },
5578                                                                                                    { "check_equal", "check_not_equal" },
5579                                                                                                    { "test_with_discard", "test_without_discard" } };
5580         static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
5581
5582         static const GLchar* subroutine_uniform_names[] = { "discard_fragment", "set_global_colors", "sample_texture",
5583                                                                                                                 "compare", "test" };
5584         static const GLuint n_subroutine_uniform_names =
5585                 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]);
5586
5587         static const GLchar* uniform_names[] = {
5588                 "sampler_1", "sampler_2",
5589         };
5590         static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]);
5591
5592         /* Colors */
5593         static const GLubyte blue_color[4]  = { 0, 0, 255, 255 };
5594         static const GLubyte clean_color[4] = { 0, 0, 0, 0 };
5595         static const GLubyte red_color[4]   = { 255, 0, 0, 255 };
5596
5597         /* Configurations */
5598         static const testConfiguration test_configurations[] = {
5599                 testConfiguration(
5600                         "Expect red color from 1st sampler", red_color, 1 /* discard_fragment  : discard_no         */,
5601                         0 /* set_global_colors : red_pass_blue_fail */, 0 /* sample_texture    : first_sampler      */,
5602                         0 /* compare           : check_equal        */, 0 /* test              : test_with_discard  */, 1 /* red */,
5603                         0 /* blue */),
5604
5605                 testConfiguration(
5606                         "Test \"without discard\" option, expect no blue color from 2nd sampler", blue_color,
5607                         0 /* discard_fragment  : discard_yes           */, 1 /* set_global_colors : blue_pass_red_fail    */,
5608                         1 /* sample_texture    : second_sampler        */, 1 /* compare           : check_not_equal       */,
5609                         1 /* test              : test_without_discard  */, 0 /* blue */, 1 /* red */),
5610
5611                 testConfiguration("Fragment shoud be discarded", clean_color, 0 /* discard_fragment  : discard_yes        */,
5612                                                   0 /* set_global_colors : red_pass_blue_fail */,
5613                                                   0 /* sample_texture    : first_sampler      */,
5614                                                   0 /* compare           : check_equal        */,
5615                                                   0 /* test              : test_with_discard  */, 1 /* red */, 0 /* blue */),
5616
5617                 testConfiguration(
5618                         "Expect blue color from 1st sampler", blue_color, 1 /* discard_fragment  : discard_no         */,
5619                         1 /* set_global_colors : blue_pass_red_fail */, 0 /* sample_texture    : first_sampler      */,
5620                         0 /* compare           : check_equal        */, 0 /* test              : test_with_discard  */,
5621                         0 /* blue */, 1 /* red */),
5622
5623                 testConfiguration(
5624                         "Expect red color from 2nd sampler", red_color, 1 /* discard_fragment  : discard_no         */,
5625                         0 /* set_global_colors : red_pass_blue_fail */, 1 /* sample_texture    : second_sampler     */,
5626                         0 /* compare           : check_equal        */, 0 /* test              : test_with_discard  */,
5627                         0 /* blue */, 1 /* red */),
5628
5629                 testConfiguration(
5630                         "Expect no blue color from 2nd sampler", blue_color, 1 /* discard_fragment  : discard_no         */,
5631                         1 /* set_global_colors : blue_pass_red_fail */, 1 /* sample_texture    : second_sampler     */,
5632                         1 /* compare           : check_not_equal    */, 0 /* test              : test_with_discard  */,
5633                         0 /* blue */, 1 /* red */),
5634         };
5635         static const GLuint n_test_cases = sizeof(test_configurations) / sizeof(test_configurations[0]);
5636
5637         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
5638         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
5639         {
5640                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
5641         }
5642
5643         /* GL objects */
5644         Utils::texture   blue_texture(m_context);
5645         Utils::texture   color_texture(m_context);
5646         Utils::framebuffer framebuffer(m_context);
5647         Utils::program   program(m_context);
5648         Utils::texture   red_texture(m_context);
5649         Utils::vertexArray vao(m_context);
5650
5651         /* Init GL objects */
5652         program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */,
5653                                   vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */);
5654
5655         program.use();
5656
5657         vao.generate();
5658         vao.bind();
5659
5660         blue_texture.create(m_texture_width, m_texture_height, GL_RGBA8);
5661         color_texture.create(m_texture_width, m_texture_height, GL_RGBA8);
5662         red_texture.create(m_texture_width, m_texture_height, GL_RGBA8);
5663
5664         framebuffer.generate();
5665         framebuffer.bind();
5666         framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height);
5667
5668         /* Get subroutine indices */
5669         for (GLuint type = 0; type < n_subroutine_types; ++type)
5670         {
5671                 m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_FRAGMENT_SHADER);
5672                 m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_FRAGMENT_SHADER);
5673         }
5674
5675         /* Get subroutine uniform locations */
5676         for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
5677         {
5678                 m_subroutine_uniform_locations[uniform] =
5679                         program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_FRAGMENT_SHADER);
5680         }
5681
5682         /* Get uniform locations */
5683         for (GLuint i = 0; i < n_uniform_names; ++i)
5684         {
5685                 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]);
5686         }
5687
5688         /* Prepare textures */
5689         fillTexture(blue_texture, blue_color);
5690         fillTexture(color_texture, clean_color);
5691         fillTexture(red_texture, red_color);
5692
5693         m_source_textures[0] = blue_texture.m_id;
5694         m_source_textures[1] = red_texture.m_id;
5695
5696         framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
5697
5698         /* Test */
5699         bool result = true;
5700         for (GLuint i = 0; i < n_test_cases; ++i)
5701         {
5702                 /* Clean output texture */
5703                 framebuffer.clear(GL_COLOR_BUFFER_BIT);
5704
5705                 /* Execute test */
5706                 if (false == testDraw(test_configurations[i].m_routines, test_configurations[i].m_samplers,
5707                                                           test_configurations[i].m_expected_color, color_texture))
5708                 {
5709                         m_context.getTestContext().getLog()
5710                                 << tcu::TestLog::Message << "Error. Failure for configuration: " << test_configurations[i].m_description
5711                                 << tcu::TestLog::EndMessage;
5712
5713                         result = false;
5714                 }
5715         }
5716
5717         /* Set result */
5718         if (true == result)
5719         {
5720                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
5721         }
5722         else
5723         {
5724                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
5725         }
5726
5727         /* Done */
5728         return tcu::TestNode::STOP;
5729 }
5730
5731 /** Fill texture with specified color
5732  *
5733  * @param texture Texture instance
5734  * @param color   Color
5735  **/
5736 void FunctionalTest11::fillTexture(Utils::texture& texture, const glw::GLubyte color[4]) const
5737 {
5738         std::vector<GLubyte> texture_data;
5739
5740         /* Prepare texture data */
5741         texture_data.resize(m_texture_width * m_texture_height * 4);
5742
5743         for (GLuint y = 0; y < m_texture_height; ++y)
5744         {
5745                 const GLuint line_offset = y * m_texture_width * 4;
5746
5747                 for (GLuint x = 0; x < m_texture_width; ++x)
5748                 {
5749                         const GLuint point_offset = x * 4 + line_offset;
5750
5751                         texture_data[point_offset + 0] = color[0]; /* red */
5752                         texture_data[point_offset + 1] = color[1]; /* green */
5753                         texture_data[point_offset + 2] = color[2]; /* blue */
5754                         texture_data[point_offset + 3] = color[3]; /* alpha */
5755                 }
5756         }
5757
5758         texture.update(m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]);
5759 }
5760
5761 /** Execute draw call and verify results
5762  *
5763  * @param routine_configuration Configurations of routines to be used
5764  * @param sampler_configuration Configuration of textures to be bound to samplers
5765  * @param expected_color        Expected color of result image
5766  *
5767  * @return true if result image is filled with expected color, false otherwise
5768  **/
5769 bool FunctionalTest11::testDraw(const glw::GLuint routine_configuration[5], const glw::GLuint sampler_configuration[2],
5770                                                                 const glw::GLubyte expected_color[4], Utils::texture& color_texture) const
5771 {
5772         const glw::Functions& gl                                        = m_context.getRenderContext().getFunctions();
5773         static const GLint      n_samplers                      = 2;
5774         static const GLint      n_subroutine_uniforms = 5;
5775         GLuint                            subroutine_indices[5];
5776
5777         /* Set samplers */
5778         for (GLuint i = 0; i < n_samplers; ++i)
5779         {
5780                 const GLuint location = m_uniform_locations[i];
5781                 const GLuint texture  = m_source_textures[sampler_configuration[i]];
5782
5783                 gl.activeTexture(GL_TEXTURE0 + i);
5784                 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture");
5785
5786                 gl.bindTexture(GL_TEXTURE_2D, texture);
5787                 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
5788
5789                 gl.uniform1i(location, i);
5790                 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i");
5791         }
5792
5793         gl.activeTexture(GL_TEXTURE0 + 0);
5794
5795         /* Set subroutine uniforms */
5796         for (GLuint i = 0; i < n_subroutine_uniforms; ++i)
5797         {
5798                 const GLuint location = m_subroutine_uniform_locations[i];
5799                 const GLuint routine  = routine_configuration[i];
5800
5801                 subroutine_indices[location] = m_subroutine_indices[i][routine];
5802         }
5803
5804         gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 5, subroutine_indices);
5805         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
5806
5807         /* Draw */
5808         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
5809         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
5810
5811         /* Capture result */
5812         std::vector<GLubyte> captured_data;
5813         captured_data.resize(m_texture_width * m_texture_height * 4);
5814
5815         color_texture.get(GL_RGBA, GL_UNSIGNED_BYTE, &captured_data[0]);
5816
5817         /* Verify result */
5818         for (GLuint y = 0; y < m_texture_height; ++y)
5819         {
5820                 const GLuint line_offset = y * m_texture_width * 4;
5821
5822                 for (GLuint x = 0; x < m_texture_width; ++x)
5823                 {
5824                         const GLuint point_offset   = x * 4 + line_offset;
5825                         bool             is_as_expected = true;
5826
5827                         is_as_expected = is_as_expected && (expected_color[0] == captured_data[point_offset + 0]); /* red */
5828                         is_as_expected = is_as_expected && (expected_color[1] == captured_data[point_offset + 1]); /* green */
5829                         is_as_expected = is_as_expected && (expected_color[2] == captured_data[point_offset + 2]); /* blue */
5830                         is_as_expected = is_as_expected && (expected_color[3] == captured_data[point_offset + 3]); /* alpha */
5831
5832                         if (false == is_as_expected)
5833                         {
5834                                 return false;
5835                         }
5836                 }
5837         }
5838
5839         /* Done */
5840         return true;
5841 }
5842
5843 /* Constatns used by FunctionalTest12 */
5844 const glw::GLuint FunctionalTest12::m_texture_height = 16;
5845 const glw::GLuint FunctionalTest12::m_texture_width  = 16;
5846
5847 /** Constructor
5848  *
5849  * @param context CTS context
5850  **/
5851 FunctionalTest12::FunctionalTest12(deqp::Context& context)
5852         : TestCase(context, "ssbo_atomic_image_load_store",
5853                            "Verify that SSBO, atomic counters and image load store work as expected")
5854         , m_left_image(0)
5855         , m_right_image(0)
5856 {
5857 }
5858
5859 /** Execute test
5860  *
5861  * @return tcu::TestNode::STOP
5862  **/
5863 tcu::TestNode::IterateResult FunctionalTest12::iterate()
5864 {
5865         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
5866         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
5867         {
5868                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
5869         }
5870
5871         bool result = true;
5872
5873         /* Test atomic counters */
5874         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters"))
5875         {
5876                 if (false == testAtomic())
5877                 {
5878                         result = false;
5879                 }
5880         }
5881
5882         /* Test shader storage buffer */
5883         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_storage_buffer_object"))
5884         {
5885                 if (false == testSSBO())
5886                 {
5887                         result = false;
5888                 }
5889         }
5890
5891         /* Test image load store */
5892         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_image_load_store"))
5893         {
5894                 if (false == testImage())
5895                 {
5896                         result = false;
5897                 }
5898         }
5899
5900         /* Set result */
5901         if (true == result)
5902         {
5903                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
5904         }
5905         else
5906         {
5907                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
5908         }
5909
5910         /* Done */
5911         return tcu::TestNode::STOP;
5912 }
5913
5914 /** Fill texture with specified color
5915  *
5916  * @param texture Texture instance
5917  * @param color   Color
5918  **/
5919 void FunctionalTest12::fillTexture(Utils::texture& texture, const glw::GLuint color[4]) const
5920 {
5921         std::vector<GLuint> texture_data;
5922
5923         /* Prepare texture data */
5924         texture_data.resize(m_texture_width * m_texture_height * 4);
5925
5926         for (GLuint y = 0; y < m_texture_height; ++y)
5927         {
5928                 const GLuint line_offset = y * m_texture_width * 4;
5929
5930                 for (GLuint x = 0; x < m_texture_width; ++x)
5931                 {
5932                         const GLuint point_offset = x * 4 + line_offset;
5933
5934                         texture_data[point_offset + 0] = color[0]; /* red */
5935                         texture_data[point_offset + 1] = color[1]; /* green */
5936                         texture_data[point_offset + 2] = color[2]; /* blue */
5937                         texture_data[point_offset + 3] = color[3]; /* alpha */
5938                 }
5939         }
5940
5941         texture.update(m_texture_width, m_texture_height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &texture_data[0]);
5942 }
5943
5944 /** Test atomic counters
5945  *
5946  * @return true if test pass, false otherwise
5947  **/
5948 bool FunctionalTest12::testAtomic()
5949 {
5950         static const GLchar* fragment_shader_code = "#version 400 core\n"
5951                                                                                                 "#extension GL_ARB_shader_atomic_counters : require\n"
5952                                                                                                 "#extension GL_ARB_shader_subroutine      : require\n"
5953                                                                                                 "\n"
5954                                                                                                 "precision highp float;\n"
5955                                                                                                 "\n"
5956                                                                                                 "layout(location = 0) out uint out_color;\n"
5957                                                                                                 "\n"
5958                                                                                                 "layout(binding = 0, offset = 8) uniform atomic_uint one;\n"
5959                                                                                                 "layout(binding = 0, offset = 4) uniform atomic_uint two;\n"
5960                                                                                                 "layout(binding = 0, offset = 0) uniform atomic_uint three;\n"
5961                                                                                                 "\n"
5962                                                                                                 "subroutine void atomic_routine(void)\n;"
5963                                                                                                 "\n"
5964                                                                                                 "subroutine(atomic_routine) void increment_two(void)\n"
5965                                                                                                 "{\n"
5966                                                                                                 "    out_color = atomicCounterIncrement(two);\n"
5967                                                                                                 "}\n"
5968                                                                                                 "\n"
5969                                                                                                 "subroutine(atomic_routine) void decrement_three(void)\n"
5970                                                                                                 "{\n"
5971                                                                                                 "    out_color = atomicCounterDecrement(three);\n"
5972                                                                                                 "}\n"
5973                                                                                                 "\n"
5974                                                                                                 "subroutine(atomic_routine) void read_one(void)\n"
5975                                                                                                 "{\n"
5976                                                                                                 "    out_color = atomicCounter(one);\n"
5977                                                                                                 "}\n"
5978                                                                                                 "\n"
5979                                                                                                 "subroutine uniform atomic_routine routine;\n"
5980                                                                                                 "\n"
5981                                                                                                 "void main()\n"
5982                                                                                                 "{\n"
5983                                                                                                 "    routine();\n"
5984                                                                                                 "}\n"
5985                                                                                                 "\n";
5986
5987         static const GLchar* geometry_shader_code = "#version 400 core\n"
5988                                                                                                 "#extension GL_ARB_shader_subroutine : require\n"
5989                                                                                                 "\n"
5990                                                                                                 "precision highp float;\n"
5991                                                                                                 "\n"
5992                                                                                                 "layout(points)                           in;\n"
5993                                                                                                 "layout(triangle_strip, max_vertices = 4) out;\n"
5994                                                                                                 "\n"
5995                                                                                                 "void main()\n"
5996                                                                                                 "{\n"
5997                                                                                                 "    gl_Position = vec4(-1, -1, 0, 1);\n"
5998                                                                                                 "    EmitVertex();\n"
5999                                                                                                 "    \n"
6000                                                                                                 "    gl_Position = vec4(-1,  1, 0, 1);\n"
6001                                                                                                 "    EmitVertex();\n"
6002                                                                                                 "    \n"
6003                                                                                                 "    gl_Position = vec4( 1, -1, 0, 1);\n"
6004                                                                                                 "    EmitVertex();\n"
6005                                                                                                 "    \n"
6006                                                                                                 "    gl_Position = vec4( 1,  1, 0, 1);\n"
6007                                                                                                 "    EmitVertex();\n"
6008                                                                                                 "    \n"
6009                                                                                                 "    EndPrimitive();\n"
6010                                                                                                 "}\n"
6011                                                                                                 "\n";
6012
6013         static const GLchar* vertex_shader_code = "#version 400 core\n"
6014                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
6015                                                                                           "\n"
6016                                                                                           "precision highp float;\n"
6017                                                                                           "\n"
6018                                                                                           "void main()\n"
6019                                                                                           "{\n"
6020                                                                                           "}\n"
6021                                                                                           "\n";
6022
6023         static const GLchar* subroutine_names[] = { "increment_two", "decrement_three", "read_one" };
6024
6025         /* Test data */
6026         static const glw::GLuint atomic_buffer_data[] = { m_texture_width * m_texture_height,
6027                                                                                                           m_texture_width * m_texture_height,
6028                                                                                                           m_texture_width * m_texture_height };
6029
6030         static const glw::GLuint expected_incremented_two[] = { atomic_buffer_data[0], 2 * atomic_buffer_data[1],
6031                                                                                                                         atomic_buffer_data[2] };
6032
6033         static const glw::GLuint expected_decremented_three[] = { 0, expected_incremented_two[1],
6034                                                                                                                           expected_incremented_two[2] };
6035
6036         static const glw::GLuint expected_read_one[] = { expected_decremented_three[0], expected_decremented_three[1],
6037                                                                                                          expected_decremented_three[2] };
6038
6039         /* GL objects */
6040         Utils::buffer     atomic_buffer(m_context);
6041         Utils::texture   color_texture(m_context);
6042         Utils::framebuffer framebuffer(m_context);
6043         Utils::program   program(m_context);
6044         Utils::vertexArray vao(m_context);
6045
6046         /* Init GL objects */
6047         program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */,
6048                                   vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */);
6049
6050         program.use();
6051
6052         vao.generate();
6053         vao.bind();
6054
6055         color_texture.create(m_texture_width, m_texture_height, GL_R32UI);
6056
6057         atomic_buffer.generate();
6058         atomic_buffer.update(GL_ATOMIC_COUNTER_BUFFER, sizeof(atomic_buffer_data), (GLvoid*)atomic_buffer_data,
6059                                                  GL_STATIC_DRAW);
6060         atomic_buffer.bindRange(GL_ATOMIC_COUNTER_BUFFER, 0 /* index */, 0 /* offset */, sizeof(atomic_buffer_data));
6061
6062         framebuffer.generate();
6063         framebuffer.bind();
6064         framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height);
6065         framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
6066         framebuffer.clear(GL_COLOR_BUFFER_BIT);
6067
6068         /* Subroutine indices */
6069         GLuint increment_two   = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER);
6070         GLuint decrement_three = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER);
6071         GLuint read_one            = program.getSubroutineIndex(subroutine_names[2], GL_FRAGMENT_SHADER);
6072
6073         /* Test */
6074         bool result = true;
6075
6076         if (false == testAtomicDraw(increment_two, expected_incremented_two))
6077         {
6078                 result = false;
6079         }
6080
6081         if (false == testAtomicDraw(decrement_three, expected_decremented_three))
6082         {
6083                 result = false;
6084         }
6085
6086         if (false == testAtomicDraw(read_one, expected_read_one))
6087         {
6088                 result = false;
6089         }
6090
6091         /* Done */
6092         return result;
6093 }
6094
6095 /** Execture draw call and verify results
6096  *
6097  * @param subroutine_index Index of subroutine that shall be used during draw call
6098  * @param expected_results Expected results
6099  *
6100  * @return true if results are as expected, false otherwise
6101  **/
6102 bool FunctionalTest12::testAtomicDraw(GLuint subroutine_index, const GLuint expected_results[3]) const
6103 {
6104         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
6105
6106         /* Set subroutine uniforms */
6107         gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index);
6108         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
6109
6110         /* Draw */
6111         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
6112         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
6113
6114         /* Capture results */
6115         GLuint* atomic_results = (GLuint*)gl.mapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_READ_ONLY);
6116         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
6117
6118         /* Verify */
6119         bool result = (0 == memcmp(expected_results, atomic_results, 3 * sizeof(GLuint)));
6120
6121         if (false == result)
6122         {
6123                 m_context.getTestContext().getLog()
6124                         << tcu::TestLog::Message << "Error. Invalid result. "
6125                         << "Result: [ " << atomic_results[0] << ", " << atomic_results[1] << ", " << atomic_results[2] << " ] "
6126                         << "Expected: [ " << expected_results[0] << ", " << expected_results[1] << ", " << expected_results[2]
6127                         << " ]" << tcu::TestLog::EndMessage;
6128         }
6129
6130         /* Unmap buffer */
6131         gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
6132         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
6133
6134         /* Done */
6135         return result;
6136 }
6137
6138 /** Test image load store
6139  *
6140  * @return true if test pass, false otherwise
6141  **/
6142 bool FunctionalTest12::testImage()
6143 {
6144         static const GLchar* fragment_shader_code =
6145                 "#version 400 core\n"
6146                 "#extension GL_ARB_shader_image_load_store : require\n"
6147                 "#extension GL_ARB_shader_subroutine       : require\n"
6148                 "\n"
6149                 "precision highp float;\n"
6150                 "\n"
6151                 "layout(location = 0) out uvec4 out_color;\n"
6152                 "\n"
6153                 "layout(rgba32ui) uniform uimage2D left_image;\n"
6154                 "layout(rgba32ui) uniform uimage2D right_image;\n"
6155                 "\n"
6156                 "subroutine void image_routine(void);\n"
6157                 "\n"
6158                 "subroutine(image_routine) void left_to_right(void)\n"
6159                 "{\n"
6160                 "    out_color = imageLoad (left_image,  ivec2(gl_FragCoord.xy));\n"
6161                 "                imageStore(right_image, ivec2(gl_FragCoord.xy), out_color);\n"
6162                 "}\n"
6163                 "\n"
6164                 "subroutine(image_routine) void right_to_left(void)\n"
6165                 "{\n"
6166                 "    out_color = imageLoad (right_image, ivec2(gl_FragCoord.xy));\n"
6167                 "                imageStore(left_image,  ivec2(gl_FragCoord.xy), out_color);\n"
6168                 "}\n"
6169                 "\n"
6170                 "subroutine uniform image_routine routine;\n"
6171                 "\n"
6172                 "void main()\n"
6173                 "{\n"
6174                 "    routine();\n"
6175                 "}\n"
6176                 "\n";
6177
6178         static const GLchar* geometry_shader_code = "#version 400 core\n"
6179                                                                                                 "#extension GL_ARB_shader_subroutine : require\n"
6180                                                                                                 "\n"
6181                                                                                                 "precision highp float;\n"
6182                                                                                                 "\n"
6183                                                                                                 "layout(points)                           in;\n"
6184                                                                                                 "layout(triangle_strip, max_vertices = 4) out;\n"
6185                                                                                                 "\n"
6186                                                                                                 "void main()\n"
6187                                                                                                 "{\n"
6188                                                                                                 "    gl_Position = vec4(-1, -1, 0, 1);\n"
6189                                                                                                 "    EmitVertex();\n"
6190                                                                                                 "    \n"
6191                                                                                                 "    gl_Position = vec4(-1,  1, 0, 1);\n"
6192                                                                                                 "    EmitVertex();\n"
6193                                                                                                 "    \n"
6194                                                                                                 "    gl_Position = vec4( 1, -1, 0, 1);\n"
6195                                                                                                 "    EmitVertex();\n"
6196                                                                                                 "    \n"
6197                                                                                                 "    gl_Position = vec4( 1,  1, 0, 1);\n"
6198                                                                                                 "    EmitVertex();\n"
6199                                                                                                 "    \n"
6200                                                                                                 "    EndPrimitive();\n"
6201                                                                                                 "}\n"
6202                                                                                                 "\n";
6203
6204         static const GLchar* vertex_shader_code = "#version 400 core\n"
6205                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
6206                                                                                           "\n"
6207                                                                                           "precision highp float;\n"
6208                                                                                           "\n"
6209                                                                                           "void main()\n"
6210                                                                                           "{\n"
6211                                                                                           "}\n"
6212                                                                                           "\n";
6213
6214         static const GLchar* subroutine_names[] = { "left_to_right", "right_to_left" };
6215
6216         static const GLchar* uniform_names[] = { "left_image", "right_image" };
6217
6218         /* Test data */
6219         static const GLuint blue_color[4]  = { 0, 0, 255, 255 };
6220         static const GLuint clean_color[4] = { 16, 32, 64, 128 };
6221         static const GLuint red_color[4]   = { 255, 0, 0, 255 };
6222
6223         /* GL objects */
6224         Utils::texture   blue_texture(m_context);
6225         Utils::texture   destination_texture(m_context);
6226         Utils::texture   color_texture(m_context);
6227         Utils::framebuffer framebuffer(m_context);
6228         Utils::program   program(m_context);
6229         Utils::texture   red_texture(m_context);
6230         Utils::vertexArray vao(m_context);
6231
6232         /* Init GL objects */
6233         program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */,
6234                                   vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */);
6235
6236         program.use();
6237
6238         vao.generate();
6239         vao.bind();
6240
6241         blue_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI);
6242         destination_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI);
6243         color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI);
6244         red_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI);
6245
6246         fillTexture(blue_texture, blue_color);
6247         fillTexture(destination_texture, clean_color);
6248         fillTexture(red_texture, red_color);
6249
6250         framebuffer.generate();
6251         framebuffer.bind();
6252         framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height);
6253         framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
6254         framebuffer.clear(GL_COLOR_BUFFER_BIT);
6255
6256         /* Subroutine indices */
6257         GLuint left_to_right = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER);
6258         GLuint right_to_left = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER);
6259
6260         /* Uniform locations */
6261         m_left_image  = program.getUniformLocation(uniform_names[0]);
6262         m_right_image = program.getUniformLocation(uniform_names[1]);
6263
6264         /* Test */
6265         bool result = true;
6266
6267         if (false == testImageDraw(left_to_right, blue_texture, destination_texture, blue_color, blue_color))
6268         {
6269                 result = false;
6270         }
6271
6272         if (false == testImageDraw(left_to_right, red_texture, destination_texture, red_color, red_color))
6273         {
6274                 result = false;
6275         }
6276
6277         if (false == testImageDraw(right_to_left, destination_texture, blue_texture, blue_color, blue_color))
6278         {
6279                 result = false;
6280         }
6281
6282         if (false == testImageDraw(right_to_left, destination_texture, red_texture, red_color, red_color))
6283         {
6284                 result = false;
6285         }
6286
6287         if (false == testImageDraw(left_to_right, blue_texture, red_texture, blue_color, blue_color))
6288         {
6289                 result = false;
6290         }
6291
6292         /* Done */
6293         return result;
6294 }
6295
6296 /** Execute draw call and verifies results
6297  *
6298  * @param subroutine_index     Index of subroutine that shall be used during draw call
6299  * @param left                 "Left" texture
6300  * @param right                "Right" texture
6301  * @param expected_left_color  Expected color of "left" texture
6302  * @param expected_right_color Expected color of "right" texture
6303  *
6304  * @return true if verification result is positive, false otherwise
6305  **/
6306 bool FunctionalTest12::testImageDraw(GLuint subroutine_index, Utils::texture& left, Utils::texture& right,
6307                                                                          const GLuint expected_left_color[4], const GLuint expected_right_color[4]) const
6308 {
6309         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
6310
6311         /* Set subroutine uniforms */
6312         gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index);
6313         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
6314
6315         /* Set up image units */
6316         gl.uniform1i(m_left_image, 0);
6317         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i");
6318
6319         gl.uniform1i(m_right_image, 1);
6320         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i");
6321
6322         gl.bindImageTexture(0, left.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI);
6323         GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture");
6324
6325         gl.bindImageTexture(1, right.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI);
6326         GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture");
6327
6328         /* Draw */
6329         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
6330         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
6331
6332         /* Verify results */
6333         bool result = true;
6334
6335         if (false == verifyTexture(left, expected_left_color))
6336         {
6337                 m_context.getTestContext().getLog() << tcu::TestLog::Message
6338                                                                                         << "Error. Invalid result. Left texture is filled with wrong color."
6339                                                                                         << tcu::TestLog::EndMessage;
6340                 result = false;
6341         }
6342
6343         if (false == verifyTexture(right, expected_right_color))
6344         {
6345                 m_context.getTestContext().getLog() << tcu::TestLog::Message
6346                                                                                         << "Error. Invalid result. Right texture is filled with wrong color."
6347                                                                                         << tcu::TestLog::EndMessage;
6348                 result = false;
6349         }
6350
6351         /* Done */
6352         return result;
6353 }
6354
6355 /** Test shader storage buffer
6356  *
6357  * @return true if test pass, false otherwise
6358  **/
6359 bool FunctionalTest12::testSSBO()
6360 {
6361         static const GLchar* fragment_shader_code = "#version 400 core\n"
6362                                                                                                 "#extension GL_ARB_shader_storage_buffer_object : require\n"
6363                                                                                                 "#extension GL_ARB_shader_subroutine            : require\n"
6364                                                                                                 "\n"
6365                                                                                                 "precision highp float;\n"
6366                                                                                                 "\n"
6367                                                                                                 "layout(location = 0) out uvec4 out_color;\n"
6368                                                                                                 "\n"
6369                                                                                                 "layout(std140, binding = 0) buffer Buffer\n"
6370                                                                                                 "{\n"
6371                                                                                                 "    uvec4 entry;\n"
6372                                                                                                 "};\n"
6373                                                                                                 "\n"
6374                                                                                                 "subroutine void ssbo_routine(void)\n;"
6375                                                                                                 "\n"
6376                                                                                                 "subroutine(ssbo_routine) void increment(void)\n"
6377                                                                                                 "{\n"
6378                                                                                                 "    out_color.x = atomicAdd(entry.x, 1);\n"
6379                                                                                                 "    out_color.y = atomicAdd(entry.y, 1);\n"
6380                                                                                                 "    out_color.z = atomicAdd(entry.z, 1);\n"
6381                                                                                                 "    out_color.w = atomicAdd(entry.w, 1);\n"
6382                                                                                                 "}\n"
6383                                                                                                 "\n"
6384                                                                                                 "subroutine(ssbo_routine) void decrement(void)\n"
6385                                                                                                 "{\n"
6386                                                                                                 "    out_color.x = atomicAdd(entry.x, -1);\n"
6387                                                                                                 "    out_color.y = atomicAdd(entry.y, -1);\n"
6388                                                                                                 "    out_color.z = atomicAdd(entry.z, -1);\n"
6389                                                                                                 "    out_color.w = atomicAdd(entry.w, -1);\n"
6390                                                                                                 "}\n"
6391                                                                                                 "\n"
6392                                                                                                 "subroutine uniform ssbo_routine routine;\n"
6393                                                                                                 "\n"
6394                                                                                                 "void main()\n"
6395                                                                                                 "{\n"
6396                                                                                                 "    routine();\n"
6397                                                                                                 "}\n"
6398                                                                                                 "\n";
6399
6400         static const GLchar* geometry_shader_code = "#version 400 core\n"
6401                                                                                                 "#extension GL_ARB_shader_subroutine : require\n"
6402                                                                                                 "\n"
6403                                                                                                 "precision highp float;\n"
6404                                                                                                 "\n"
6405                                                                                                 "layout(points)                           in;\n"
6406                                                                                                 "layout(triangle_strip, max_vertices = 4) out;\n"
6407                                                                                                 "\n"
6408                                                                                                 "void main()\n"
6409                                                                                                 "{\n"
6410                                                                                                 "    gl_Position = vec4(-1, -1, 0, 1);\n"
6411                                                                                                 "    EmitVertex();\n"
6412                                                                                                 "    \n"
6413                                                                                                 "    gl_Position = vec4(-1,  1, 0, 1);\n"
6414                                                                                                 "    EmitVertex();\n"
6415                                                                                                 "    \n"
6416                                                                                                 "    gl_Position = vec4( 1, -1, 0, 1);\n"
6417                                                                                                 "    EmitVertex();\n"
6418                                                                                                 "    \n"
6419                                                                                                 "    gl_Position = vec4( 1,  1, 0, 1);\n"
6420                                                                                                 "    EmitVertex();\n"
6421                                                                                                 "    \n"
6422                                                                                                 "    EndPrimitive();\n"
6423                                                                                                 "}\n"
6424                                                                                                 "\n";
6425
6426         static const GLchar* vertex_shader_code = "#version 400 core\n"
6427                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
6428                                                                                           "\n"
6429                                                                                           "precision highp float;\n"
6430                                                                                           "\n"
6431                                                                                           "void main()\n"
6432                                                                                           "{\n"
6433                                                                                           "}\n"
6434                                                                                           "\n";
6435
6436         static const GLchar* subroutine_names[] = { "increment", "decrement" };
6437
6438         /* Test data */
6439         static const glw::GLuint buffer_data[] = { m_texture_width * m_texture_height + 1,
6440                                                                                            m_texture_width * m_texture_height + 2,
6441                                                                                            m_texture_width * m_texture_height + 3,
6442                                                                                            m_texture_width * m_texture_height + 4 };
6443
6444         static const glw::GLuint expected_incremented[] = { m_texture_width * m_texture_height + buffer_data[0],
6445                                                                                                                 m_texture_width * m_texture_height + buffer_data[1],
6446                                                                                                                 m_texture_width * m_texture_height + buffer_data[2],
6447                                                                                                                 m_texture_width * m_texture_height + buffer_data[3] };
6448
6449         static const glw::GLuint expected_decremented[] = { buffer_data[0], buffer_data[1], buffer_data[2],
6450                                                                                                                 buffer_data[3] };
6451
6452         /* GL objects */
6453         Utils::buffer     buffer(m_context);
6454         Utils::texture   color_texture(m_context);
6455         Utils::framebuffer framebuffer(m_context);
6456         Utils::program   program(m_context);
6457         Utils::vertexArray vao(m_context);
6458
6459         /* Init GL objects */
6460         program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */,
6461                                   vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */);
6462
6463         program.use();
6464
6465         vao.generate();
6466         vao.bind();
6467
6468         color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI);
6469
6470         buffer.generate();
6471         buffer.update(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), (GLvoid*)buffer_data, GL_STATIC_DRAW);
6472         buffer.bindRange(GL_SHADER_STORAGE_BUFFER, 0 /* index */, 0 /* offset */, sizeof(buffer_data));
6473
6474         framebuffer.generate();
6475         framebuffer.bind();
6476         framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height);
6477         framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
6478         framebuffer.clear(GL_COLOR_BUFFER_BIT);
6479
6480         /* Subroutine indices */
6481         GLuint increment = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER);
6482         GLuint decrement = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER);
6483
6484         /* Test */
6485         bool result = true;
6486
6487         if (false == testSSBODraw(increment, expected_incremented))
6488         {
6489                 result = false;
6490         }
6491
6492         if (false == testSSBODraw(decrement, expected_decremented))
6493         {
6494                 result = false;
6495         }
6496
6497         /* Done */
6498         return result;
6499 }
6500
6501 /** Execute draw call and verify results
6502  *
6503  * @param subroutine_index Index of subroutine that shall be used by draw call
6504  * @param expected_results Expected results
6505  *
6506  *
6507  **/
6508 bool FunctionalTest12::testSSBODraw(GLuint subroutine_index, const GLuint expected_results[4]) const
6509 {
6510         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
6511
6512         /* Set subroutine uniforms */
6513         gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index);
6514         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
6515
6516         /* Draw */
6517         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
6518         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
6519
6520         /* Capture results */
6521         GLuint* ssbo_results = (GLuint*)gl.mapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
6522         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
6523
6524         /* Verify */
6525         bool result = (0 == memcmp(expected_results, ssbo_results, 4 * sizeof(GLuint)));
6526
6527         if (false == result)
6528         {
6529                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result. "
6530                                                                                         << "Result: [ " << ssbo_results[0] << ", " << ssbo_results[1] << ", "
6531                                                                                         << ssbo_results[2] << ", " << ssbo_results[3] << " ] "
6532                                                                                         << "Expected: [ " << expected_results[0] << ", " << expected_results[1]
6533                                                                                         << ", " << expected_results[2] << ", " << expected_results[3] << " ]"
6534                                                                                         << tcu::TestLog::EndMessage;
6535         }
6536
6537         /* Unmap buffer */
6538         gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
6539         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
6540
6541         /* Done */
6542         return result;
6543 }
6544
6545 /** Check if texture is filled with expected color
6546  *
6547  * @param texture        Texture instance
6548  * @param expected_color Expected color
6549  *
6550  * @return true if texture is filled with specified color, false otherwise
6551  **/
6552 bool FunctionalTest12::verifyTexture(Utils::texture& texture, const GLuint expected_color[4]) const
6553 {
6554         std::vector<GLuint> results;
6555         results.resize(m_texture_width * m_texture_height * 4);
6556
6557         texture.get(GL_RGBA_INTEGER, GL_UNSIGNED_INT, &results[0]);
6558
6559         for (GLuint y = 0; y < m_texture_height; ++y)
6560         {
6561                 const GLuint line_offset = y * m_texture_width * 4;
6562
6563                 for (GLuint x = 0; x < m_texture_width; ++x)
6564                 {
6565                         const GLuint point_offset = line_offset + x * 4;
6566                         bool             result           = true;
6567
6568                         result = result && (results[point_offset + 0] == expected_color[0]);
6569                         result = result && (results[point_offset + 1] == expected_color[1]);
6570                         result = result && (results[point_offset + 2] == expected_color[2]);
6571                         result = result && (results[point_offset + 3] == expected_color[3]);
6572
6573                         if (false == result)
6574                         {
6575                                 return false;
6576                         }
6577                 }
6578         }
6579
6580         return true;
6581 }
6582
6583 /** Constructor.
6584  *
6585  *  @param context Rendering context.
6586  *
6587  **/
6588 FunctionalTest13::FunctionalTest13(deqp::Context& context)
6589         : TestCase(context, "subroutines_with_separate_shader_objects",
6590                            "Verifies that subroutines work correctly when used in separate "
6591                            "shader objects")
6592         , m_fbo_id(0)
6593         , m_pipeline_id(0)
6594         , m_read_buffer(DE_NULL)
6595         , m_to_height(4)
6596         , m_to_id(0)
6597         , m_to_width(4)
6598         , m_vao_id(0)
6599         , m_has_test_passed(true)
6600 {
6601         memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids));
6602         memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids));
6603         memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids));
6604         memset(m_te_po_ids, 0, sizeof(m_te_po_ids));
6605         memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids));
6606 }
6607
6608 /** Deinitializes all GL objects that may have been created during test
6609  *  execution, as well as releases all process-side buffers that may have
6610  *  been allocated during the process.
6611  *  The function also restores default GL state configuration.
6612  **/
6613 void FunctionalTest13::deinit()
6614 {
6615         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
6616
6617         if (m_fbo_id != 0)
6618         {
6619                 gl.deleteFramebuffers(1, &m_fbo_id);
6620
6621                 m_fbo_id = 0;
6622         }
6623
6624         if (m_pipeline_id != 0)
6625         {
6626                 gl.deleteProgramPipelines(1, &m_pipeline_id);
6627
6628                 m_pipeline_id = 0;
6629         }
6630
6631         if (m_read_buffer != DE_NULL)
6632         {
6633                 delete[] m_read_buffer;
6634
6635                 m_read_buffer = DE_NULL;
6636         }
6637
6638         for (unsigned int n_id = 0; n_id < 2 /* po id variants */; ++n_id)
6639         {
6640                 if (m_fs_po_ids[n_id] != 0)
6641                 {
6642                         gl.deleteProgram(m_fs_po_ids[n_id]);
6643
6644                         m_fs_po_ids[n_id] = 0;
6645                 }
6646
6647                 if (m_gs_po_ids[n_id] != 0)
6648                 {
6649                         gl.deleteProgram(m_gs_po_ids[n_id]);
6650
6651                         m_gs_po_ids[n_id] = 0;
6652                 }
6653
6654                 if (m_tc_po_ids[n_id] != 0)
6655                 {
6656                         gl.deleteProgram(m_tc_po_ids[n_id]);
6657
6658                         m_tc_po_ids[n_id] = 0;
6659                 }
6660
6661                 if (m_te_po_ids[n_id] != 0)
6662                 {
6663                         gl.deleteProgram(m_te_po_ids[n_id]);
6664
6665                         m_te_po_ids[n_id] = 0;
6666                 }
6667
6668                 if (m_vs_po_ids[n_id] != 0)
6669                 {
6670                         gl.deleteProgram(m_vs_po_ids[n_id]);
6671
6672                         m_vs_po_ids[n_id] = 0;
6673                 }
6674         } /* for (both shader program object variants) */
6675
6676         if (m_to_id != 0)
6677         {
6678                 gl.deleteTextures(1, &m_to_id);
6679
6680                 m_to_id = 0;
6681         }
6682
6683         if (m_vao_id != 0)
6684         {
6685                 gl.deleteVertexArrays(1, &m_vao_id);
6686
6687                 m_vao_id = 0;
6688         }
6689
6690         /* Restore default GL_PATCH_VERTICES setting value */
6691         gl.patchParameteri(GL_PATCH_VERTICES, 3);
6692
6693         /* Restore default GL_PACK_ALIGNMENT setting value */
6694         gl.pixelStorei(GL_PACK_ALIGNMENT, 4);
6695 }
6696
6697 /** Retrieves body of a fragment shader that should be used for the test.
6698  *  The subroutine implementations are slightly changed, depending on the
6699  *  index of the shader, as specified by the caller.
6700  *
6701  *  @param n_id Index of the shader.
6702  *
6703  *  @return Requested string.
6704  **/
6705 std::string FunctionalTest13::getFragmentShaderBody(unsigned int n_id)
6706 {
6707         std::stringstream result_sstream;
6708
6709         /* Pre-amble */
6710         result_sstream << "#version 400\n"
6711                                           "\n"
6712                                           "#extension GL_ARB_shader_subroutine : require\n"
6713                                           "\n"
6714                                           /* Sub-routine */
6715                                           "subroutine void SubroutineFSType(inout vec4 result);\n"
6716                                           "\n"
6717                                           "subroutine(SubroutineFSType) void SubroutineFS1(inout vec4 result)\n"
6718                                           "{\n"
6719                                           "    result += vec4("
6720                                    << float(n_id + 1) / 10.0f << ", " << float(n_id + 2) / 10.0f << ", " << float(n_id + 3) / 10.0f
6721                                    << ", " << float(n_id + 4) / 10.0f
6722                                    << ");\n"
6723                                           "}\n"
6724                                           "subroutine(SubroutineFSType) void SubroutineFS2(inout vec4 result)\n"
6725                                           "{\n"
6726                                           "    result += vec4("
6727                                    << float(n_id + 1) / 20.0f << ", " << float(n_id + 2) / 20.0f << ", " << float(n_id + 3) / 20.0f
6728                                    << ", " << float(n_id + 4) / 20.0f << ");\n"
6729                                                                                                                  "}\n"
6730                                                                                                                  "\n"
6731                                                                                                                  "subroutine uniform SubroutineFSType function;\n"
6732                                                                                                                  "\n"
6733                                                                                                                  /* Input block */
6734                                                                                                                  "in GS_DATA\n"
6735                                                                                                                  "{\n"
6736                                                                                                                  "    vec4 data;\n"
6737                                                                                                                  "} in_gs;\n"
6738                                                                                                                  "\n"
6739                                                                                                                  "out vec4 result;\n"
6740                                                                                                                  /* main() declaration */
6741                                                                                                                  "void main()\n"
6742                                                                                                                  "{\n"
6743                                                                                                                  "    vec4 data = in_gs.data;\n"
6744                                                                                                                  "    function(data);\n"
6745                                                                                                                  "\n"
6746                                                                                                                  "    result = data;\n"
6747                                                                                                                  "}\n";
6748
6749         return result_sstream.str();
6750 }
6751
6752 /** Retrieves body of a geometry shader that should be used for the test.
6753  *  The subroutine implementations are slightly changed, depending on the
6754  *  index of the shader, as specified by the caller.
6755  *
6756  *  @param n_id Index of the shader.
6757  *
6758  *  @return Requested string.
6759  **/
6760 std::string FunctionalTest13::getGeometryShaderBody(unsigned int n_id)
6761 {
6762         std::stringstream result_sstream;
6763
6764         /* Pre-amble */
6765         result_sstream << "#version 400\n"
6766                                           "\n"
6767                                           "#extension GL_ARB_shader_subroutine : require\n"
6768                                           "\n"
6769                                           "layout(points)                           in;\n"
6770                                           "layout(triangle_strip, max_vertices = 4) out;\n"
6771                                           /* Sub-routine */
6772                                           "subroutine void SubroutineGSType(inout vec4 result);\n"
6773                                           "\n"
6774                                           "subroutine(SubroutineGSType) void SubroutineGS1(inout vec4 result)\n"
6775                                           "{\n"
6776                                           "    result += vec4(0, 0, 0, "
6777                                    << float(n_id + 1) * 0.425f << ");\n"
6778                                                                                                   "}\n"
6779                                                                                                   "subroutine(SubroutineGSType) void SubroutineGS2(inout vec4 result)\n"
6780                                                                                                   "{\n"
6781                                                                                                   "    result += vec4(0, 0, 0, "
6782                                    << float(n_id + 1) * 0.0425f << ");\n"
6783                                                                                                    "}\n"
6784                                                                                                    "\n"
6785                                                                                                    "subroutine uniform SubroutineGSType function;\n"
6786                                                                                                    "\n"
6787                                                                                                    /* Input block */
6788                                                                                                    "in TE_DATA\n"
6789                                                                                                    "{\n"
6790                                                                                                    "    vec4 data;\n"
6791                                                                                                    "} in_te[];\n"
6792                                                                                                    "\n"
6793                                                                                                    /* Output block */
6794                                                                                                    "out GS_DATA\n"
6795                                                                                                    "{\n"
6796                                                                                                    "    vec4 data;\n"
6797                                                                                                    "} out_gs;\n"
6798                                                                                                    "\n"
6799                                                                                                    "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"
6800                                                                                                    "out gl_PerVertex { vec4 gl_Position; };\n"
6801                                                                                                    /* main() declaration */
6802                                                                                                    "void main()\n"
6803                                                                                                    "{\n"
6804                                                                                                    "    vec4 data = in_te[0].data;\n"
6805                                                                                                    "\n"
6806                                                                                                    "    function(data);\n"
6807                                                                                                    "\n"
6808                                                                                                    "    gl_Position = vec4(1, -1, 0, 1);\n"
6809                                                                                                    "    out_gs.data = data;\n"
6810                                                                                                    "    EmitVertex();\n"
6811                                                                                                    "\n"
6812                                                                                                    "    gl_Position = vec4(-1, -1, 0, 1);\n"
6813                                                                                                    "    out_gs.data = data;\n"
6814                                                                                                    "    EmitVertex();\n"
6815                                                                                                    "\n"
6816                                                                                                    "    gl_Position = vec4(1, 1, 0, 1);\n"
6817                                                                                                    "    out_gs.data = data;\n"
6818                                                                                                    "    EmitVertex();\n"
6819                                                                                                    "\n"
6820                                                                                                    "    gl_Position = vec4(-1, 1, 0, 1);\n"
6821                                                                                                    "    out_gs.data = data;\n"
6822                                                                                                    "    EmitVertex();\n"
6823                                                                                                    "    EndPrimitive();\n"
6824                                                                                                    "}\n";
6825
6826         return result_sstream.str();
6827 }
6828
6829 /** Retrieves body of a tessellation control shader that should be used for the test.
6830  *  The subroutine implementations are slightly changed, depending on the
6831  *  index of the shader, as specified by the caller.
6832  *
6833  *  @param n_id Index of the shader.
6834  *
6835  *  @return Requested string.
6836  **/
6837 std::string FunctionalTest13::getTessellationControlShaderBody(unsigned int n_id)
6838 {
6839         std::stringstream result_sstream;
6840
6841         /* Pre-amble */
6842         result_sstream << "#version 400\n"
6843                                           "\n"
6844                                           "#extension GL_ARB_shader_subroutine : require\n"
6845                                           "\n"
6846                                           "layout(vertices = 4) out;\n"
6847                                           /* Sub-routine */
6848                                           "subroutine void SubroutineTCType(inout vec4 result);\n"
6849                                           "\n"
6850                                           "subroutine(SubroutineTCType) void SubroutineTC1(inout vec4 result)\n"
6851                                           "{\n"
6852                                           "    result += vec4(0, "
6853                                    << float(n_id + 1) * 0.25f << ", 0, 0);\n"
6854                                                                                                  "}\n"
6855                                                                                                  "subroutine(SubroutineTCType) void SubroutineTC2(inout vec4 result)\n"
6856                                                                                                  "{\n"
6857                                                                                                  "    result += vec4(0, "
6858                                    << float(n_id + 1) * 0.025f
6859                                    << ", 0, 0);\n"
6860                                           "}\n"
6861                                           "\n"
6862                                           "subroutine uniform SubroutineTCType function;\n"
6863                                           "\n"
6864                                           /* Input block */
6865                                           "in VS_DATA\n"
6866                                           "{\n"
6867                                           "    vec4 data;\n"
6868                                           "} in_vs[];\n"
6869                                           "\n"
6870                                           /* Output block */
6871                                           "out TC_DATA\n"
6872                                           "{\n"
6873                                           "    vec4 data;\n"
6874                                           "} out_tc[];\n"
6875                                           "\n"
6876                                           "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"
6877                                           "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n"
6878                                           /* main() declaration */
6879                                           "void main()\n"
6880                                           "{\n"
6881                                           "    gl_TessLevelOuter[0]                = 1.0;\n"
6882                                           "    gl_TessLevelOuter[1]                = 1.0;\n"
6883                                           "    gl_TessLevelOuter[2]                = 1.0;\n"
6884                                           "    gl_TessLevelOuter[3]                = 1.0;\n"
6885                                           "    gl_TessLevelInner[0]                = 1.0;\n"
6886                                           "    gl_TessLevelInner[1]                = 1.0;\n"
6887                                           "    gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position;\n"
6888                                           "    out_tc[gl_InvocationID].data        = in_vs[0].data;\n"
6889                                           "\n"
6890                                           "    function(out_tc[gl_InvocationID].data);\n"
6891                                           "}\n";
6892
6893         return result_sstream.str();
6894 }
6895
6896 /** Retrieves body of a tessellation evaluation shader that should be used for the test.
6897  *  The subroutine implementations are slightly changed, depending on the
6898  *  index of the shader, as specified by the caller.
6899  *
6900  *  @param n_id Index of the shader.
6901  *
6902  *  @return Requested string.
6903  **/
6904 std::string FunctionalTest13::getTessellationEvaluationShaderBody(unsigned int n_id)
6905 {
6906         std::stringstream result_sstream;
6907
6908         /* Pre-amble */
6909         result_sstream << "#version 400\n"
6910                                           "\n"
6911                                           "#extension GL_ARB_shader_subroutine : require\n"
6912                                           "\n"
6913                                           "layout(quads, point_mode) in;\n"
6914                                           /* Sub-routine */
6915                                           "subroutine void SubroutineTEType(inout vec4 result);\n"
6916                                           "\n"
6917                                           "subroutine(SubroutineTEType) void SubroutineTE1(inout vec4 result)\n"
6918                                           "{\n"
6919                                           "    result += vec4(0, 0, "
6920                                    << float(n_id + 1) * 0.325f << ", 0);\n"
6921                                                                                                   "}\n"
6922                                                                                                   "subroutine(SubroutineTEType) void SubroutineTE2(inout vec4 result)\n"
6923                                                                                                   "{\n"
6924                                                                                                   "    result += vec4(0, 0, "
6925                                    << float(n_id + 1) * 0.0325f << ", 0);\n"
6926                                                                                                    "}\n"
6927                                                                                                    "\n"
6928                                                                                                    "subroutine uniform SubroutineTEType function;\n"
6929                                                                                                    "\n"
6930                                                                                                    /* Input block */
6931                                                                                                    "in TC_DATA\n"
6932                                                                                                    "{\n"
6933                                                                                                    "    vec4 data;\n"
6934                                                                                                    "} in_tc[];\n"
6935                                                                                                    "\n"
6936                                                                                                    /* Output block */
6937                                                                                                    "out TE_DATA\n"
6938                                                                                                    "{\n"
6939                                                                                                    "    vec4 data;\n"
6940                                                                                                    "} out_te;\n"
6941                                                                                                    "\n"
6942                                                                                                    "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"
6943                                                                                                    "out gl_PerVertex { vec4 gl_Position; };\n"
6944                                                                                                    /* main() declaration */
6945                                                                                                    "void main()\n"
6946                                                                                                    "{\n"
6947                                                                                                    "    gl_Position = gl_in[0].gl_Position;\n"
6948                                                                                                    "    out_te.data = in_tc[0].data;\n"
6949                                                                                                    "\n"
6950                                                                                                    "    function(out_te.data);\n"
6951                                                                                                    "}\n";
6952
6953         return result_sstream.str();
6954 }
6955
6956 /** Retrieves body of a vertex shader that should be used for the test.
6957  *  The subroutine implementations are slightly changed, depending on the
6958  *  index of the shader, as specified by the caller.
6959  *
6960  *  @param n_id Index of the shader.
6961  *
6962  *  @return Requested string.
6963  **/
6964 std::string FunctionalTest13::getVertexShaderBody(unsigned int n_id)
6965 {
6966         std::stringstream result_sstream;
6967
6968         /* Pre-amble */
6969         result_sstream << "#version 400\n"
6970                                           "\n"
6971                                           "#extension GL_ARB_shader_subroutine : require\n"
6972                                           "\n"
6973                                           /* Sub-routine */
6974                                           "subroutine void SubroutineVSType(inout vec4 result);\n"
6975                                           "\n"
6976                                           "subroutine(SubroutineVSType) void SubroutineVS1(inout vec4 result)\n"
6977                                           "{\n"
6978                                           "    result += vec4("
6979                                    << float(n_id + 1) * 0.125f << ", 0, 0, 0);\n"
6980                                                                                                   "}\n"
6981                                                                                                   "subroutine(SubroutineVSType) void SubroutineVS2(inout vec4 result)\n"
6982                                                                                                   "{\n"
6983                                                                                                   "    result += vec4("
6984                                    << float(n_id + 1) * 0.0125f << ", 0, 0, 0);\n"
6985                                                                                                    "}\n"
6986                                                                                                    "\n"
6987                                                                                                    "subroutine uniform SubroutineVSType function;\n"
6988                                                                                                    "\n"
6989                                                                                                    /* Output block */
6990                                                                                                    "out VS_DATA\n"
6991                                                                                                    "{\n"
6992                                                                                                    "    vec4 data;\n"
6993                                                                                                    "} out_vs;\n"
6994                                                                                                    "\n"
6995                                                                                                    "out gl_PerVertex { vec4 gl_Position; };\n"
6996                                                                                                    /* main() declaration */
6997                                                                                                    "void main()\n"
6998                                                                                                    "{\n"
6999                                                                                                    "    gl_Position = vec4(0, 0, 0, 1);\n"
7000                                                                                                    "    out_vs.data = vec4(0);\n"
7001                                                                                                    "\n"
7002                                                                                                    "    function(out_vs.data);\n"
7003                                                                                                    "\n"
7004                                                                                                    "}\n";
7005
7006         return result_sstream.str();
7007 }
7008
7009 /** Initializes all GL objects required to run the test. Also modifies a few
7010  *  GL states in order for the test to run correctly.
7011  **/
7012 void FunctionalTest13::initTest()
7013 {
7014         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
7015
7016         /* Set up viewport */
7017         gl.viewport(0 /* x */, 0 /* y */, m_to_width, m_to_height);
7018         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed.");
7019
7020         /* Make sure no program is used */
7021         gl.useProgram(0);
7022         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
7023
7024         /* Generate a pipeline object */
7025         gl.genProgramPipelines(1, &m_pipeline_id);
7026         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed.");
7027
7028         gl.bindProgramPipeline(m_pipeline_id);
7029         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed.");
7030
7031         /* Initialize all shader programs */
7032         for (unsigned int n_id = 0; n_id < 2 /* variants for each shader type */; ++n_id)
7033         {
7034                 std::string fs_body                     = getFragmentShaderBody(n_id);
7035                 const char* fs_body_raw_ptr = fs_body.c_str();
7036                 std::string gs_body                     = getGeometryShaderBody(n_id);
7037                 const char* gs_body_raw_ptr = gs_body.c_str();
7038                 std::string tc_body                     = getTessellationControlShaderBody(n_id);
7039                 const char* tc_body_raw_ptr = tc_body.c_str();
7040                 std::string te_body                     = getTessellationEvaluationShaderBody(n_id);
7041                 const char* te_body_raw_ptr = te_body.c_str();
7042                 std::string vs_body                     = getVertexShaderBody(n_id);
7043                 const char* vs_body_raw_ptr = vs_body.c_str();
7044
7045                 m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr);
7046                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
7047
7048                 m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr);
7049                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
7050
7051                 m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr);
7052                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
7053
7054                 m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr);
7055                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
7056
7057                 m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr);
7058                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
7059
7060                 /* Verify that all shader program objects have been linked successfully */
7061                 const glw::GLuint po_ids[] = {
7062                         m_fs_po_ids[n_id], m_gs_po_ids[n_id], m_tc_po_ids[n_id], m_te_po_ids[n_id], m_vs_po_ids[n_id],
7063                 };
7064                 const unsigned int n_po_ids = sizeof(po_ids) / sizeof(po_ids[0]);
7065
7066                 for (unsigned int n_po_id = 0; n_po_id < n_po_ids; ++n_po_id)
7067                 {
7068                         glw::GLint  link_status = GL_FALSE;
7069                         glw::GLuint po_id               = po_ids[n_po_id];
7070
7071                         gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status);
7072                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
7073
7074                         if (link_status != GL_TRUE)
7075                         {
7076                                 TCU_FAIL("Shader program object linking failed.");
7077                         }
7078                 } /* for (all shader program objects) */
7079         }        /* for (both shader program object variants) */
7080
7081         /* Generate a texture object. We will use the base mip-map as a render-target */
7082         gl.genTextures(1, &m_to_id);
7083         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed.");
7084
7085         gl.bindTexture(GL_TEXTURE_2D, m_to_id);
7086         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed.");
7087
7088         gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA32F, m_to_width, m_to_height);
7089         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed");
7090
7091         /* Generate and configure a FBO we will use for the draw call */
7092         gl.genFramebuffers(1, &m_fbo_id);
7093         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed.");
7094
7095         gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
7096         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed.");
7097
7098         gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);
7099         GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed.");
7100
7101         /* Generate & bind a VAO */
7102         gl.genVertexArrays(1, &m_vao_id);
7103         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
7104
7105         gl.bindVertexArray(m_vao_id);
7106         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
7107
7108         /* Set up tessellation */
7109         gl.patchParameteri(GL_PATCH_VERTICES, 1);
7110         GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed.");
7111
7112         /* Set up pixel storage alignment */
7113         gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
7114         GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed.");
7115
7116         /* Allocate enough space to hold color attachment data */
7117         m_read_buffer = (unsigned char*)new float[m_to_width * m_to_height * 4 /* rgba */];
7118 }
7119
7120 /** Executes test iteration.
7121  *
7122  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
7123  */
7124 tcu::TestNode::IterateResult FunctionalTest13::iterate()
7125 {
7126         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
7127
7128         /* Do not execute the test if GL_ARB_shader_subroutine and GL_ARB_separate_shader_objects
7129          * are not supported */
7130         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
7131         {
7132                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
7133         }
7134
7135         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects"))
7136         {
7137                 throw tcu::NotSupportedError("GL_ARB_separate_shader_objects is not supported");
7138         }
7139
7140         /* Initialize all GL objects before we continue */
7141         initTest();
7142
7143         /* Iterate over all possible FS/GS/TC/TE/VS permutations */
7144         for (int n_shader_permutation = 0; n_shader_permutation < 32 /* 2^5 */; ++n_shader_permutation)
7145         {
7146                 const unsigned int n_fs_idx = ((n_shader_permutation & (1 << 0)) != 0) ? 1 : 0;
7147                 const unsigned int n_gs_idx = ((n_shader_permutation & (1 << 1)) != 0) ? 1 : 0;
7148                 const unsigned int n_tc_idx = ((n_shader_permutation & (1 << 2)) != 0) ? 1 : 0;
7149                 const unsigned int n_te_idx = ((n_shader_permutation & (1 << 3)) != 0) ? 1 : 0;
7150                 const unsigned int n_vs_idx = ((n_shader_permutation & (1 << 4)) != 0) ? 1 : 0;
7151                 const unsigned int fs_po_id = m_fs_po_ids[n_fs_idx];
7152                 const unsigned int gs_po_id = m_gs_po_ids[n_gs_idx];
7153                 const unsigned int tc_po_id = m_tc_po_ids[n_tc_idx];
7154                 const unsigned int te_po_id = m_te_po_ids[n_te_idx];
7155                 const unsigned int vs_po_id = m_vs_po_ids[n_vs_idx];
7156
7157                 /* Configure fragment shader stage */
7158                 gl.useProgramStages(m_pipeline_id, GL_FRAGMENT_SHADER_BIT, fs_po_id);
7159                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_FRAGMENT_SHADER_BIT bit");
7160
7161                 /* Configure geometry shader stage */
7162                 gl.useProgramStages(m_pipeline_id, GL_GEOMETRY_SHADER_BIT, gs_po_id);
7163                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_GEOMETRY_SHADER_BIT bit");
7164
7165                 /* Configure tessellation control shader stage */
7166                 gl.useProgramStages(m_pipeline_id, GL_TESS_CONTROL_SHADER_BIT, tc_po_id);
7167                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_CONTROL_SHADER_BIT bit");
7168
7169                 /* Configure tessellation evaluation shader stage */
7170                 gl.useProgramStages(m_pipeline_id, GL_TESS_EVALUATION_SHADER_BIT, te_po_id);
7171                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_EVALUATION_SHADER_BIT bit");
7172
7173                 /* Configure vertex shader stage */
7174                 gl.useProgramStages(m_pipeline_id, GL_VERTEX_SHADER_BIT, vs_po_id);
7175                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_VERTEX_SHADER_BIT bit");
7176
7177                 /* Validate the pipeline */
7178                 glw::GLint validate_status = GL_FALSE;
7179
7180                 gl.validateProgramPipeline(m_pipeline_id);
7181                 GLU_EXPECT_NO_ERROR(gl.getError(), "glValidateProgramPipeline() call failed.");
7182
7183                 gl.getProgramPipelineiv(m_pipeline_id, GL_VALIDATE_STATUS, &validate_status);
7184                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed.");
7185
7186                 if (validate_status != GL_TRUE)
7187                 {
7188                         TCU_FAIL("Program pipeline has not been validated successfully.");
7189                 }
7190
7191                 /* Retrieve subroutine indices */
7192                 GLuint fs_subroutine_indices[2] = { (GLuint)-1 };
7193                 GLint  fs_subroutine_uniform_index = 0;
7194                 GLuint gs_subroutine_indices[2] = { (GLuint)-1 };
7195                 GLint  gs_subroutine_uniform_index = 0;
7196                 GLuint tc_subroutine_indices[2] = { (GLuint)-1 };
7197                 GLint  tc_subroutine_uniform_index = 0;
7198                 GLuint te_subroutine_indices[2] = { (GLuint)-1 };
7199                 GLint  te_subroutine_uniform_index = 0;
7200                 GLuint vs_subroutine_indices[2] = { (GLuint)-1 };
7201                 GLint  vs_subroutine_uniform_index = 0;
7202
7203                 for (unsigned int n_subroutine = 0; n_subroutine < 2; ++n_subroutine)
7204                 {
7205                         std::stringstream fs_subroutine_name_sstream;
7206                         std::stringstream gs_subroutine_name_sstream;
7207                         std::stringstream tc_subroutine_name_sstream;
7208                         std::stringstream te_subroutine_name_sstream;
7209                         std::stringstream vs_subroutine_name_sstream;
7210
7211                         fs_subroutine_name_sstream << "SubroutineFS" << (n_subroutine + 1);
7212                         gs_subroutine_name_sstream << "SubroutineGS" << (n_subroutine + 1);
7213                         tc_subroutine_name_sstream << "SubroutineTC" << (n_subroutine + 1);
7214                         te_subroutine_name_sstream << "SubroutineTE" << (n_subroutine + 1);
7215                         vs_subroutine_name_sstream << "SubroutineVS" << (n_subroutine + 1);
7216
7217                         fs_subroutine_indices[n_subroutine] =
7218                                 gl.getSubroutineIndex(fs_po_id, GL_FRAGMENT_SHADER, fs_subroutine_name_sstream.str().c_str());
7219                         gs_subroutine_indices[n_subroutine] =
7220                                 gl.getSubroutineIndex(gs_po_id, GL_GEOMETRY_SHADER, gs_subroutine_name_sstream.str().c_str());
7221                         tc_subroutine_indices[n_subroutine] =
7222                                 gl.getSubroutineIndex(tc_po_id, GL_TESS_CONTROL_SHADER, tc_subroutine_name_sstream.str().c_str());
7223                         te_subroutine_indices[n_subroutine] =
7224                                 gl.getSubroutineIndex(te_po_id, GL_TESS_EVALUATION_SHADER, te_subroutine_name_sstream.str().c_str());
7225                         vs_subroutine_indices[n_subroutine] =
7226                                 gl.getSubroutineIndex(vs_po_id, GL_VERTEX_SHADER, vs_subroutine_name_sstream.str().c_str());
7227                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed.");
7228
7229                         if (fs_subroutine_indices[n_subroutine] == (GLuint)-1 ||
7230                                 gs_subroutine_indices[n_subroutine] == (GLuint)-1 ||
7231                                 tc_subroutine_indices[n_subroutine] == (GLuint)-1 ||
7232                                 te_subroutine_indices[n_subroutine] == (GLuint)-1 || vs_subroutine_indices[n_subroutine] == (GLuint)-1)
7233                         {
7234                                 m_testCtx.getLog() << tcu::TestLog::Message
7235                                                                    << "At least one subroutine was not recognized by glGetSubroutineIndex() call. "
7236                                                                           "(fs:"
7237                                                                    << fs_subroutine_indices[n_subroutine]
7238                                                                    << ", gs:" << gs_subroutine_indices[n_subroutine]
7239                                                                    << ", tc:" << tc_subroutine_indices[n_subroutine]
7240                                                                    << ", te:" << te_subroutine_indices[n_subroutine]
7241                                                                    << ", vs:" << vs_subroutine_indices[n_subroutine] << ")."
7242                                                                    << tcu::TestLog::EndMessage;
7243
7244                                 TCU_FAIL("At least one subroutine was not recognized");
7245                         }
7246                 } /* for (both subroutines) */
7247
7248                 /* Retrieve subroutine uniform indices */
7249                 fs_subroutine_uniform_index = gl.getSubroutineUniformLocation(fs_po_id, GL_FRAGMENT_SHADER, "function");
7250                 gs_subroutine_uniform_index = gl.getSubroutineUniformLocation(gs_po_id, GL_GEOMETRY_SHADER, "function");
7251                 tc_subroutine_uniform_index = gl.getSubroutineUniformLocation(tc_po_id, GL_TESS_CONTROL_SHADER, "function");
7252                 te_subroutine_uniform_index = gl.getSubroutineUniformLocation(te_po_id, GL_TESS_EVALUATION_SHADER, "function");
7253                 vs_subroutine_uniform_index = gl.getSubroutineUniformLocation(vs_po_id, GL_VERTEX_SHADER, "function");
7254
7255                 if (fs_subroutine_uniform_index == -1 || gs_subroutine_uniform_index == -1 ||
7256                         tc_subroutine_uniform_index == -1 || te_subroutine_uniform_index == -1 || vs_subroutine_uniform_index == -1)
7257                 {
7258                         m_testCtx.getLog() << tcu::TestLog::Message << "At least one subroutine uniform is considered inactive by "
7259                                                                                                                    "glGetSubroutineUniformLocation ("
7260                                                                                                                    "fs:"
7261                                                            << fs_subroutine_uniform_index << ", gs:" << gs_subroutine_uniform_index
7262                                                            << ", tc:" << tc_subroutine_uniform_index << ", te:" << te_subroutine_uniform_index
7263                                                            << ", vs:" << vs_subroutine_uniform_index << ")." << tcu::TestLog::EndMessage;
7264
7265                         TCU_FAIL("At least one subroutine uniform is considered inactive");
7266                 }
7267
7268                 /* Check if both subroutines work correctly in each stage */
7269                 for (int n_subroutine_permutation = 0; n_subroutine_permutation < 32; /* 2^5 */
7270                          ++n_subroutine_permutation)
7271                 {
7272                         unsigned int n_fs_subroutine = ((n_subroutine_permutation & (1 << 0)) != 0) ? 1 : 0;
7273                         unsigned int n_gs_subroutine = ((n_subroutine_permutation & (1 << 1)) != 0) ? 1 : 0;
7274                         unsigned int n_tc_subroutine = ((n_subroutine_permutation & (1 << 2)) != 0) ? 1 : 0;
7275                         unsigned int n_te_subroutine = ((n_subroutine_permutation & (1 << 3)) != 0) ? 1 : 0;
7276                         unsigned int n_vs_subroutine = ((n_subroutine_permutation & (1 << 4)) != 0) ? 1 : 0;
7277
7278                         /* Configure subroutine uniforms */
7279                         struct
7280                         {
7281                                 glw::GLenum  stage;
7282                                 glw::GLuint  po_id;
7283                                 glw::GLuint* indices;
7284                         } configurations[] = {
7285                                 { GL_FRAGMENT_SHADER, fs_po_id, fs_subroutine_indices + n_fs_subroutine },
7286                                 { GL_GEOMETRY_SHADER, gs_po_id, gs_subroutine_indices + n_gs_subroutine },
7287                                 { GL_TESS_CONTROL_SHADER, tc_po_id, tc_subroutine_indices + n_tc_subroutine },
7288                                 { GL_TESS_EVALUATION_SHADER, te_po_id, te_subroutine_indices + n_te_subroutine },
7289                                 { GL_VERTEX_SHADER, vs_po_id, vs_subroutine_indices + n_vs_subroutine },
7290                         };
7291
7292                         for (int i = 0; i < 5; ++i)
7293                         {
7294                                 gl.activeShaderProgram(m_pipeline_id, configurations[i].po_id);
7295                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveShaderProgram() call failed.");
7296
7297                                 gl.uniformSubroutinesuiv(configurations[i].stage, 1 /* count */, configurations[i].indices);
7298                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed.");
7299                         }
7300
7301                         /* Render a full-screen quad with the pipeline */
7302                         gl.clear(GL_COLOR_BUFFER_BIT);
7303                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed.");
7304
7305                         gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */);
7306                         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
7307
7308                         /* Read color attachment's contents */
7309                         gl.readPixels(0, /* x */
7310                                                   0, /* y */
7311                                                   m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_read_buffer);
7312                         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed.");
7313
7314                         /* Verify the contents */
7315                         verifyReadBuffer(n_fs_idx, n_fs_subroutine, n_gs_idx, n_gs_subroutine, n_tc_idx, n_tc_subroutine, n_te_idx,
7316                                                          n_te_subroutine, n_vs_idx, n_vs_subroutine);
7317                 } /* for (all subroutine permutations) */
7318         }        /* for (all program shader object permutations) */
7319
7320         /** All done */
7321         if (m_has_test_passed)
7322         {
7323                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
7324         }
7325         else
7326         {
7327                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
7328         }
7329
7330         return STOP;
7331 }
7332
7333 /** Verifies the data that have been rendered using a pipeline object.
7334  *  Contents of the data depends on indices of the shaders, as well as
7335  *  on the subroutines that have been activated for particular iteration.
7336  *
7337  *  @param n_fs_id         Index of the fragment shader used for the iteration;
7338  *  @param n_fs_subroutine Index of the subroutine used in the fragment shader
7339  *                         for the iteration;
7340  *  @param n_gs_id         Index of the geometry shader used for the iteration;
7341  *  @param n_gs_subroutine Index of the subroutine used in the geometry shader
7342  *                         for the iteration;
7343  *  @param n_tc_id         Index of the tessellation control shader used for the iteration;
7344  *  @param n_tc_subroutine Index of the subroutine used in the tessellation control
7345  *                         shader for the iteration;
7346  *  @param n_te_id         Index of the tessellation evaluation shader used for the iteration;
7347  *  @param n_te_subroutine Index of the subroutine used in the tessellation evaluation
7348  *                         shader for the iteration;
7349  *  @param n_vs_id         Index of the vertex shader used for the iteration;
7350  *  @param n_vs_subroutine Index of the subroutine used in the vertex shader for
7351  *                         the iteration.
7352  */
7353 void FunctionalTest13::verifyReadBuffer(unsigned int n_fs_id, unsigned int n_fs_subroutine, unsigned int n_gs_id,
7354                                                                                 unsigned int n_gs_subroutine, unsigned int n_tc_id,
7355                                                                                 unsigned int n_tc_subroutine, unsigned int n_te_id,
7356                                                                                 unsigned int n_te_subroutine, unsigned int n_vs_id,
7357                                                                                 unsigned int n_vs_subroutine)
7358 {
7359         float expected_color[4] = { 0 };
7360         float fs_modifier[4]    = { 0 };
7361         float gs_modifier[4]    = { 0 };
7362         float tc_modifier[4]    = { 0 };
7363         float te_modifier[4]    = { 0 };
7364         float vs_modifier[4]    = { 0 };
7365
7366         if (n_fs_subroutine == 0)
7367         {
7368                 for (unsigned int n_component = 0; n_component < 4; ++n_component)
7369                 {
7370                         fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 10.0f;
7371                 }
7372         }
7373         else
7374         {
7375                 for (unsigned int n_component = 0; n_component < 4; ++n_component)
7376                 {
7377                         fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 20.0f;
7378                 }
7379         }
7380
7381         if (n_gs_subroutine == 0)
7382         {
7383                 gs_modifier[3] = float(n_gs_id + 1) * 0.425f;
7384         }
7385         else
7386         {
7387                 gs_modifier[3] = float(n_gs_id + 1) * 0.0425f;
7388         }
7389
7390         if (n_tc_subroutine == 0)
7391         {
7392                 tc_modifier[1] = float(n_tc_id + 1) * 0.25f;
7393         }
7394         else
7395         {
7396                 tc_modifier[1] = float(n_tc_id + 1) * 0.025f;
7397         }
7398
7399         if (n_te_subroutine == 0)
7400         {
7401                 te_modifier[2] = float(n_te_id + 1) * 0.325f;
7402         }
7403         else
7404         {
7405                 te_modifier[2] = float(n_te_id + 1) * 0.0325f;
7406         }
7407
7408         if (n_vs_subroutine == 0)
7409         {
7410                 vs_modifier[0] = float(n_vs_id + 1) * 0.125f;
7411         }
7412         else
7413         {
7414                 vs_modifier[0] = float(n_vs_id + 1) * 0.0125f;
7415         }
7416
7417         /* Determine the expected color */
7418         for (unsigned int n_component = 0; n_component < 4 /* rgba */; ++n_component)
7419         {
7420                 expected_color[n_component] = fs_modifier[n_component] + gs_modifier[n_component] + tc_modifier[n_component] +
7421                                                                           te_modifier[n_component] + vs_modifier[n_component];
7422         }
7423
7424         /* Verify all read texels are valid */
7425         const float epsilon                     = 1e-5f;
7426         bool            should_continue = true;
7427
7428         for (unsigned int y = 0; y < m_to_height && should_continue; ++y)
7429         {
7430                 const float* row_ptr = (const float*)m_read_buffer + y * m_to_width * 4; /* rgba */
7431
7432                 for (unsigned int x = 0; x < m_to_width && should_continue; ++x)
7433                 {
7434                         const float* texel_ptr = row_ptr + x * 4; /* rgba */
7435
7436                         if (de::abs(texel_ptr[0] - expected_color[0]) > epsilon ||
7437                                 de::abs(texel_ptr[1] - expected_color[1]) > epsilon ||
7438                                 de::abs(texel_ptr[2] - expected_color[2]) > epsilon ||
7439                                 de::abs(texel_ptr[3] - expected_color[3]) > epsilon)
7440                         {
7441                                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel rendered at (" << x << ", " << y
7442                                                                    << ") for "
7443                                                                           "the following configuration: "
7444                                                                           "n_fs_id:"
7445                                                                    << n_fs_id << " n_fs_subroutine:" << n_fs_subroutine << " n_gs_id:" << n_gs_id
7446                                                                    << " n_gs_subroutine:" << n_gs_subroutine << " n_tc_id:" << n_tc_id
7447                                                                    << " n_tc_subroutine:" << n_tc_subroutine << " n_te_id:" << n_te_id
7448                                                                    << " n_te_subroutine:" << n_te_subroutine << " n_vs_id:" << n_vs_id
7449                                                                    << " n_vs_subroutine:" << n_vs_subroutine << "; expected:"
7450                                                                                                                                                                 "("
7451                                                                    << expected_color[0] << ", " << expected_color[1] << ", " << expected_color[2]
7452                                                                    << ", " << expected_color[3] << "), found:"
7453                                                                                                                                    "("
7454                                                                    << texel_ptr[0] << ", " << texel_ptr[1] << ", " << texel_ptr[2] << ", "
7455                                                                    << texel_ptr[3] << ")." << tcu::TestLog::EndMessage;
7456
7457                                 m_has_test_passed = false;
7458                                 should_continue   = false;
7459                         }
7460                 } /* for (all columns) */
7461         }        /* for (all rows) */
7462 }
7463
7464 /** Constructor
7465  *
7466  * @param context CTS context
7467  **/
7468 FunctionalTest14_15::FunctionalTest14_15(deqp::Context& context)
7469         : TestCase(context, "structure_parameters_program_binary", "Verify structures can be used as parameters")
7470         , m_uniform_location(0)
7471 {
7472 }
7473
7474 /** Execute test
7475  *
7476  * @return tcu::TestNode::STOP
7477  **/
7478 tcu::TestNode::IterateResult FunctionalTest14_15::iterate()
7479 {
7480         static const GLchar* vertex_shader_code =
7481                 "#version 400 core\n"
7482                 "#extension GL_ARB_shader_subroutine : require\n"
7483                 "\n"
7484                 "precision highp float;\n"
7485                 "\n"
7486                 "struct data\n"
7487                 "{\n"
7488                 "    uint r;\n"
7489                 "    uint g;\n"
7490                 "    uint b;\n"
7491                 "    uint a;\n"
7492                 "};\n"
7493                 "\n"
7494                 "subroutine void routine_type_1(in data iparam, out data oparam);\n"
7495                 "subroutine void routine_type_2(inout data arg);\n"
7496                 "\n"
7497                 "subroutine (routine_type_1) void invert(in data iparam, out data oparam)\n"
7498                 "{\n"
7499                 "    oparam.r = iparam.a;\n"
7500                 "    oparam.g = iparam.b;\n"
7501                 "    oparam.b = iparam.g;\n"
7502                 "    oparam.a = iparam.r;\n"
7503                 "}\n"
7504                 "\n"
7505                 "subroutine (routine_type_1) void increment(in data iparam, out data oparam)\n"
7506                 "{\n"
7507                 "    oparam.r = 1 + iparam.r;\n"
7508                 "    oparam.g = 1 + iparam.g;\n"
7509                 "    oparam.b = 1 + iparam.b;\n"
7510                 "    oparam.a = 1 + iparam.a;\n"
7511                 "}\n"
7512                 "\n"
7513                 "subroutine (routine_type_2) void div_by_2(inout data arg)\n"
7514                 "{\n"
7515                 "    arg.r = arg.r / 2;\n"
7516                 "    arg.g = arg.g / 2;\n"
7517                 "    arg.b = arg.b / 2;\n"
7518                 "    arg.a = arg.a / 2;\n"
7519                 "}\n"
7520                 "\n"
7521                 "subroutine (routine_type_2) void decrement(inout data arg)\n"
7522                 "{\n"
7523                 "    arg.r = arg.r - 1;\n"
7524                 "    arg.g = arg.g - 1;\n"
7525                 "    arg.b = arg.b - 1;\n"
7526                 "    arg.a = arg.a - 1;\n"
7527                 "}\n"
7528                 "\n"
7529                 "subroutine uniform routine_type_1 routine_1;\n"
7530                 "subroutine uniform routine_type_2 routine_2;\n"
7531                 "\n"
7532                 "uniform uvec4 uni_input;\n"
7533                 "\n"
7534                 "out uvec4 out_routine_1;\n"
7535                 "out uvec4 out_routine_2;\n"
7536                 "\n"
7537                 "\n"
7538                 "void main()\n"
7539                 "{\n"
7540                 "    data routine_1_input;\n"
7541                 "    data routine_1_output;\n"
7542                 "    data routine_2_arg;\n"
7543                 "\n"
7544                 "    routine_1_input.r = uni_input.r;\n"
7545                 "    routine_1_input.g = uni_input.g;\n"
7546                 "    routine_1_input.b = uni_input.b;\n"
7547                 "    routine_1_input.a = uni_input.a;\n"
7548                 "\n"
7549                 "    routine_2_arg.r = uni_input.r;\n"
7550                 "    routine_2_arg.g = uni_input.g;\n"
7551                 "    routine_2_arg.b = uni_input.b;\n"
7552                 "    routine_2_arg.a = uni_input.a;\n"
7553                 "\n"
7554                 "    routine_1(routine_1_input, routine_1_output);\n"
7555                 "    routine_2(routine_2_arg);\n"
7556                 "\n"
7557                 "    out_routine_1.r = routine_1_output.r;\n"
7558                 "    out_routine_1.g = routine_1_output.g;\n"
7559                 "    out_routine_1.b = routine_1_output.b;\n"
7560                 "    out_routine_1.a = routine_1_output.a;\n"
7561                 "\n"
7562                 "    out_routine_2.r = routine_2_arg.r;\n"
7563                 "    out_routine_2.g = routine_2_arg.g;\n"
7564                 "    out_routine_2.b = routine_2_arg.b;\n"
7565                 "    out_routine_2.a = routine_2_arg.a;\n"
7566                 "}\n"
7567                 "\n";
7568
7569         static const GLchar* subroutine_names[][2] = { { "invert", "increment" }, { "div_by_2", "decrement" } };
7570         static const GLuint  n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
7571
7572         static const GLchar* subroutine_uniform_names[] = { "routine_1", "routine_2" };
7573         static const GLuint  n_subroutine_uniform_names =
7574                 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]);
7575
7576         static const GLchar* uniform_name       = "uni_input";
7577         static const GLchar* varying_names[] = { "out_routine_1", "out_routine_2" };
7578
7579         static const GLuint n_varying_names                                = sizeof(varying_names) / sizeof(varying_names[0]);
7580         static const GLuint transform_feedback_buffer_size = n_varying_names * 4 * sizeof(GLuint);
7581
7582         /* Test data */
7583         static const Utils::vec4<GLuint> uni_input[] = { Utils::vec4<GLuint>(8, 64, 4096, 16777216),
7584                                                                                                          Utils::vec4<GLuint>(8, 64, 4096, 16777216) };
7585
7586         static const Utils::vec4<GLuint> out_routine_1[] = { Utils::vec4<GLuint>(16777216, 4096, 64, 8),
7587                                                                                                                  Utils::vec4<GLuint>(9, 65, 4097, 16777217) };
7588
7589         static const Utils::vec4<GLuint> out_routine_2[] = { Utils::vec4<GLuint>(4, 32, 2048, 8388608),
7590                                                                                                                  Utils::vec4<GLuint>(7, 63, 4095, 16777215) };
7591
7592         static const GLuint n_test_cases = 2;
7593
7594         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
7595         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
7596         {
7597                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
7598         }
7599
7600         /* GL objects */
7601         Utils::program   program(m_context);
7602         Utils::buffer     transform_feedback_buffer(m_context);
7603         Utils::vertexArray vao(m_context);
7604
7605         bool is_program_binary_supported = program.isProgramBinarySupported();
7606
7607         /* Init GL objects */
7608         program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code,
7609                                   varying_names /* varying_names */, n_varying_names /* n_varyings */);
7610
7611         /* Do not execute the test if GL_ARB_get_program_binary is not supported */
7612         if (true == is_program_binary_supported)
7613         {
7614                 /* Get subroutine indices */
7615                 for (GLuint type = 0; type < n_subroutine_types; ++type)
7616                 {
7617                         m_initial_subroutine_indices[type][0] =
7618                                 program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER);
7619
7620                         m_initial_subroutine_indices[type][1] =
7621                                 program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER);
7622                 }
7623
7624                 /* Get subroutine uniform locations */
7625                 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
7626                 {
7627                         m_initial_subroutine_uniform_locations[uniform] =
7628                                 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER);
7629                 }
7630
7631                 /* Delete program and recreate it from binary */
7632                 std::vector<GLubyte> program_binary;
7633                 GLenum                           binary_format;
7634
7635                 program.getBinary(program_binary, binary_format);
7636                 program.remove();
7637                 program.createFromBinary(program_binary, binary_format);
7638         }
7639
7640         program.use();
7641
7642         vao.generate();
7643         vao.bind();
7644
7645         transform_feedback_buffer.generate();
7646         transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */,
7647                                                                          GL_DYNAMIC_COPY);
7648         transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size);
7649
7650         /* Get subroutine indices */
7651         for (GLuint type = 0; type < n_subroutine_types; ++type)
7652         {
7653                 m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER);
7654                 m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER);
7655         }
7656
7657         /* Get subroutine uniform locations */
7658         for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
7659         {
7660                 m_subroutine_uniform_locations[uniform] =
7661                         program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER);
7662         }
7663
7664         /* Get uniform locations */
7665         m_uniform_location = program.getUniformLocation(uniform_name);
7666
7667         /* Test */
7668         bool result = true;
7669
7670         /* Test program binary */
7671         if (true == is_program_binary_supported)
7672         {
7673                 /* Test indices and locations */
7674                 if (false == testIndicesAndLocations())
7675                 {
7676                         static const GLuint n_subroutines_per_type = 2;
7677
7678                         m_context.getTestContext().getLog() << tcu::TestLog::Message
7679                                                                                                 << "Error. Subroutine indices or subroutine uniform location changed."
7680                                                                                                 << tcu::TestLog::EndMessage;
7681
7682                         for (GLuint type = 0; type < n_subroutine_types; ++type)
7683                         {
7684                                 for (GLuint i = 0; i < n_subroutines_per_type; ++i)
7685                                 {
7686                                         m_context.getTestContext().getLog()
7687                                                 << tcu::TestLog::Message << "Subroutine: " << subroutine_names[type][i]
7688                                                 << " index: " << m_subroutine_indices[type][i]
7689                                                 << " initial index: " << m_initial_subroutine_indices[type][i] << tcu::TestLog::EndMessage;
7690                                 }
7691                         }
7692
7693                         for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform)
7694                         {
7695                                 m_context.getTestContext().getLog()
7696                                         << tcu::TestLog::Message << "Subroutine uniform: " << subroutine_uniform_names[uniform]
7697                                         << " location: " << m_subroutine_uniform_locations[uniform]
7698                                         << " initial location: " << m_initial_subroutine_uniform_locations[uniform]
7699                                         << tcu::TestLog::EndMessage;
7700                         }
7701
7702                         result = false;
7703                 }
7704
7705                 /* Test draw with deafult set of subroutines */
7706                 if (false == testDefaultSubroutineSet(uni_input[0], out_routine_1, out_routine_2))
7707                 {
7708                         result = false;
7709                 }
7710         }
7711
7712         for (GLuint i = 0; i < n_test_cases; ++i)
7713         {
7714                 if (false == testDraw(i, uni_input[i], out_routine_1[i], out_routine_2[i]))
7715                 {
7716                         result = false;
7717                 }
7718         }
7719
7720         /* Set result */
7721         if (true == result)
7722         {
7723                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
7724         }
7725         else
7726         {
7727                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
7728         }
7729
7730         /* Done */
7731         return tcu::TestNode::STOP;
7732 }
7733
7734 /** Execute draw call and verify results
7735  *
7736  * @param uni_input                 Input data
7737  * @param expected_routine_1_result Set of expected results of "routine_1"
7738  * @param expected_routine_2_result Set of expected results of "routine_2"
7739  *
7740  * @return true if test pass, false otherwise
7741  **/
7742 bool FunctionalTest14_15::testDefaultSubroutineSet(const Utils::vec4<glw::GLuint>& uni_input,
7743                                                                                                    const Utils::vec4<glw::GLuint>  expected_routine_1_result[2],
7744                                                                                                    const Utils::vec4<glw::GLuint>  expected_routine_2_result[2]) const
7745 {
7746         const glw::Functions& gl         = m_context.getRenderContext().getFunctions();
7747         bool                              result = true;
7748
7749         /* Set up input data uniforms */
7750         gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w);
7751         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
7752
7753         /* Execute draw call with transform feedback */
7754         gl.beginTransformFeedback(GL_POINTS);
7755         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
7756
7757         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
7758         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
7759
7760         gl.endTransformFeedback();
7761         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
7762
7763         /* Capture results */
7764         GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
7765         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
7766
7767         Utils::vec4<GLuint> routine_1_result;
7768         Utils::vec4<GLuint> routine_2_result;
7769
7770         routine_1_result.m_x = feedback_data[0 + 0];
7771         routine_1_result.m_y = feedback_data[0 + 1];
7772         routine_1_result.m_z = feedback_data[0 + 2];
7773         routine_1_result.m_w = feedback_data[0 + 3];
7774
7775         routine_2_result.m_x = feedback_data[4 + 0];
7776         routine_2_result.m_y = feedback_data[4 + 1];
7777         routine_2_result.m_z = feedback_data[4 + 2];
7778         routine_2_result.m_w = feedback_data[4 + 3];
7779
7780         /* Unmap buffer */
7781         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
7782         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
7783
7784         /* Verifiy */
7785         result = result &&
7786                          ((routine_1_result == expected_routine_1_result[0]) || (routine_1_result == expected_routine_1_result[1]));
7787
7788         result = result &&
7789                          ((routine_2_result == expected_routine_2_result[0]) || (routine_2_result == expected_routine_2_result[1]));
7790
7791         /* Log error if any */
7792         if (false == result)
7793         {
7794                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
7795                                                                                         << tcu::TestLog::EndMessage;
7796
7797                 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
7798
7799                 message << "Routine_1, result: ";
7800
7801                 routine_1_result.log(message);
7802
7803                 message << "Routine_2, result: ";
7804
7805                 routine_2_result.log(message);
7806
7807                 message << tcu::TestLog::EndMessage;
7808         }
7809
7810         /* Done */
7811         return result;
7812 }
7813
7814 /** Execute draw call and verify results
7815  *
7816  * @param routine_configuration     Subroutine "type" ordinal
7817  * @param uni_input                 Input data
7818  * @param expected_routine_1_result Expected results of "routine_1"
7819  * @param expected_routine_2_result Expected results of "routine_2"
7820  *
7821  * @return true if test pass, false otherwise
7822  **/
7823 bool FunctionalTest14_15::testDraw(glw::GLuint routine_configuration, const Utils::vec4<glw::GLuint>& uni_input,
7824                                                                    const Utils::vec4<glw::GLuint>& expected_routine_1_result,
7825                                                                    const Utils::vec4<glw::GLuint>& expected_routine_2_result) const
7826 {
7827         const glw::Functions& gl         = m_context.getRenderContext().getFunctions();
7828         bool                              result = true;
7829         GLuint                            subroutine_indices[2];
7830         static const GLuint   n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]);
7831
7832         /* Set up input data uniforms */
7833         gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w);
7834         GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f");
7835
7836         /* Prepare subroutine uniform data */
7837         for (GLuint i = 0; i < n_subroutine_uniforms; ++i)
7838         {
7839                 const GLuint location = m_subroutine_uniform_locations[i];
7840
7841                 subroutine_indices[location] = m_subroutine_indices[i][routine_configuration];
7842         }
7843
7844         /* Set up subroutine uniforms */
7845         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]);
7846         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
7847
7848         /* Execute draw call with transform feedback */
7849         gl.beginTransformFeedback(GL_POINTS);
7850         GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");
7851
7852         gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
7853         GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");
7854
7855         gl.endTransformFeedback();
7856         GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");
7857
7858         /* Capture results */
7859         GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
7860         GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");
7861
7862         Utils::vec4<GLuint> routine_1_result;
7863         Utils::vec4<GLuint> routine_2_result;
7864
7865         routine_1_result.m_x = feedback_data[0 + 0];
7866         routine_1_result.m_y = feedback_data[0 + 1];
7867         routine_1_result.m_z = feedback_data[0 + 2];
7868         routine_1_result.m_w = feedback_data[0 + 3];
7869
7870         routine_2_result.m_x = feedback_data[4 + 0];
7871         routine_2_result.m_y = feedback_data[4 + 1];
7872         routine_2_result.m_z = feedback_data[4 + 2];
7873         routine_2_result.m_w = feedback_data[4 + 3];
7874
7875         /* Unmap buffer */
7876         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
7877         GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");
7878
7879         /* Verifiy */
7880         result = result && (routine_1_result == expected_routine_1_result);
7881         result = result && (routine_2_result == expected_routine_2_result);
7882
7883         /* Log error if any */
7884         if (false == result)
7885         {
7886                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
7887                                                                                         << tcu::TestLog::EndMessage;
7888
7889                 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message;
7890
7891                 message << "Routine_1, result: ";
7892
7893                 routine_1_result.log(message);
7894
7895                 message << ", expected: ";
7896
7897                 expected_routine_1_result.log(message);
7898
7899                 message << "Routine_2, result: ";
7900
7901                 routine_2_result.log(message);
7902
7903                 message << ", expected: ";
7904
7905                 expected_routine_2_result.log(message);
7906
7907                 message << tcu::TestLog::EndMessage;
7908         }
7909
7910         /* Done */
7911         return result;
7912 }
7913
7914 /** Verify initial and current values of subroutine indices and subroutines uniform locations
7915  *
7916  * @return true if test pass, false otherwise
7917  **/
7918 bool FunctionalTest14_15::testIndicesAndLocations() const
7919 {
7920         static const GLuint n_subroutine_types = 2;
7921         bool                            result                     = true;
7922
7923         /* Verify subroutine indices */
7924         for (GLuint type = 0; type < n_subroutine_types; ++type)
7925         {
7926                 result = result && (m_subroutine_indices[type][0] == m_initial_subroutine_indices[type][0]);
7927                 result = result && (m_subroutine_indices[type][1] == m_initial_subroutine_indices[type][1]);
7928         }
7929
7930         /* Verify subroutine uniform locations */
7931         for (GLuint uniform = 0; uniform < n_subroutine_types; ++uniform)
7932         {
7933                 result = result && (m_subroutine_uniform_locations[uniform] == m_initial_subroutine_uniform_locations[uniform]);
7934         }
7935
7936         return result;
7937 }
7938
7939 /** Constructor.
7940  *
7941  *  @param context Rendering context.
7942  *
7943  **/
7944 FunctionalTest16::FunctionalTest16(deqp::Context& context)
7945         : TestCase(context, "subroutine_uniform_reset",
7946                            "Checks that when the active program for a shader stage is re-linke or "
7947                            "changed by a call to UseProgram, BindProgramPipeline, or UseProgramStages,"
7948                            " subroutine uniforms for that stage are reset to arbitrarily chosen default "
7949                            "functions with compatible subroutine types.")
7950         , m_are_pipeline_objects_supported(false)
7951         , m_has_test_passed(true)
7952 {
7953         memset(m_fs_ids, 0, sizeof(m_fs_ids));
7954         memset(m_gs_ids, 0, sizeof(m_gs_ids));
7955         memset(m_po_ids, 0, sizeof(m_po_ids));
7956         memset(m_tc_ids, 0, sizeof(m_tc_ids));
7957         memset(m_te_ids, 0, sizeof(m_te_ids));
7958         memset(m_vs_ids, 0, sizeof(m_vs_ids));
7959
7960         memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids));
7961         memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids));
7962         memset(m_pipeline_object_ids, 0, sizeof(m_pipeline_object_ids));
7963         memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids));
7964         memset(m_te_po_ids, 0, sizeof(m_te_po_ids));
7965         memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids));
7966 }
7967
7968 /** Deinitializes all GL objects that may have been created during test execution. */
7969 void FunctionalTest16::deinit()
7970 {
7971         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
7972
7973         for (unsigned int n_id = 0; n_id < 2; ++n_id)
7974         {
7975                 if (m_fs_ids[n_id] != 0)
7976                 {
7977                         gl.deleteShader(m_fs_ids[n_id]);
7978
7979                         m_fs_ids[n_id] = 0;
7980                 }
7981
7982                 if (m_fs_po_ids[n_id] != 0)
7983                 {
7984                         gl.deleteProgram(m_fs_po_ids[n_id]);
7985
7986                         m_fs_po_ids[n_id] = 0;
7987                 }
7988
7989                 if (m_gs_ids[n_id] != 0)
7990                 {
7991                         gl.deleteShader(m_gs_ids[n_id]);
7992
7993                         m_gs_ids[n_id] = 0;
7994                 }
7995
7996                 if (m_gs_po_ids[n_id] != 0)
7997                 {
7998                         gl.deleteProgram(m_gs_po_ids[n_id]);
7999
8000                         m_gs_po_ids[n_id] = 0;
8001                 }
8002
8003                 if (m_pipeline_object_ids[n_id] != 0)
8004                 {
8005                         gl.deleteProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id);
8006                 }
8007
8008                 if (m_po_ids[n_id] != 0)
8009                 {
8010                         gl.deleteProgram(m_po_ids[n_id]);
8011
8012                         m_po_ids[n_id] = 0;
8013                 }
8014
8015                 if (m_tc_ids[n_id] != 0)
8016                 {
8017                         gl.deleteShader(m_tc_ids[n_id]);
8018
8019                         m_tc_ids[n_id] = 0;
8020                 }
8021
8022                 if (m_tc_po_ids[n_id] != 0)
8023                 {
8024                         gl.deleteProgram(m_tc_po_ids[n_id]);
8025
8026                         m_tc_po_ids[n_id] = 0;
8027                 }
8028
8029                 if (m_te_ids[n_id] != 0)
8030                 {
8031                         gl.deleteShader(m_te_ids[n_id]);
8032
8033                         m_te_ids[n_id] = 0;
8034                 }
8035
8036                 if (m_te_po_ids[n_id] != 0)
8037                 {
8038                         gl.deleteProgram(m_te_po_ids[n_id]);
8039
8040                         m_te_po_ids[n_id] = 0;
8041                 }
8042
8043                 if (m_vs_ids[n_id] != 0)
8044                 {
8045                         gl.deleteShader(m_vs_ids[n_id]);
8046
8047                         m_vs_ids[n_id] = 0;
8048                 }
8049
8050                 if (m_vs_po_ids[n_id] != 0)
8051                 {
8052                         gl.deleteProgram(m_vs_po_ids[n_id]);
8053
8054                         m_vs_po_ids[n_id] = 0;
8055                 }
8056         } /* for (both IDs) */
8057 }
8058
8059 /** Retrieves body of a shader that should be used for user-specified shader stage.
8060  *  This function returns slightly different implementations, depending on index of
8061  *  the program/pipeline object the shader will be used for.
8062  *
8063  *  @param shader_stage Stage the shader body is to be returned for.
8064  *  @param n_id         Index of the shader (as per description).
8065  *
8066  *  @return Requested string.
8067  **/
8068 std::string FunctionalTest16::getShaderBody(const Utils::_shader_stage& shader_stage, const unsigned int& n_id) const
8069 {
8070         std::stringstream result_sstream;
8071
8072         result_sstream << "#version 400\n"
8073                                           "\n"
8074                                           "#extension GL_ARB_shader_subroutine : require\n"
8075                                           "\n";
8076
8077         switch (shader_stage)
8078         {
8079         case Utils::SHADER_STAGE_VERTEX:
8080         {
8081                 result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n";
8082                 break;
8083         }
8084         case Utils::SHADER_STAGE_GEOMETRY:
8085         {
8086                 result_sstream << "layout(points)                   in;\n"
8087                                                   "layout(points, max_vertices = 1) out;\n";
8088                 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n";
8089                 result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n";
8090                 break;
8091         }
8092
8093         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
8094         {
8095                 result_sstream << "layout(vertices = 4) out;\n";
8096                 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n";
8097                 result_sstream << "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n";
8098                 break;
8099         }
8100
8101         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
8102         {
8103                 result_sstream << "layout(quads) in;\n";
8104                 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n";
8105                 result_sstream << "out gl_PerVertex { vec4 gl_Position; };\n";
8106                 break;
8107         }
8108
8109         default:
8110                 break;
8111         } /* switch (shader_stage) */
8112
8113         result_sstream << "\n"
8114                                           "subroutine void subroutineType (inout vec4 result);\n"
8115                                           "subroutine vec4 subroutineType2(in    vec4 data);\n"
8116                                           "\n"
8117                                           "subroutine(subroutineType) void function1(inout vec4 result)\n"
8118                                           "{\n"
8119                                           "    result += vec4("
8120                                    << (n_id + 1) << ", " << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4)
8121                                    << ");\n"
8122                                           "}\n"
8123                                           "subroutine(subroutineType) void function2(inout vec4 result)\n"
8124                                           "{\n"
8125                                           "    result += vec4("
8126                                    << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4) << ", " << (n_id + 5)
8127                                    << ");\n"
8128                                           "}\n"
8129                                           "\n"
8130                                           "subroutine(subroutineType2) vec4 function3(in vec4 data)\n"
8131                                           "{\n"
8132                                           "    return data * data;\n"
8133                                           "}\n"
8134                                           "subroutine(subroutineType2) vec4 function4(in vec4 data)\n"
8135                                           "{\n"
8136                                           "    return data + data;\n"
8137                                           "}\n"
8138                                           "\n"
8139                                           "subroutine uniform subroutineType  subroutine1;\n"
8140                                           "subroutine uniform subroutineType  subroutine2;\n"
8141                                           "subroutine uniform subroutineType2 subroutine3;\n"
8142                                           "subroutine uniform subroutineType2 subroutine4;\n"
8143                                           "\n";
8144
8145         if (shader_stage == Utils::SHADER_STAGE_FRAGMENT)
8146         {
8147                 result_sstream << "out vec4 result;\n";
8148         }
8149
8150         result_sstream << "void main()\n"
8151                                           "{\n";
8152
8153         switch (shader_stage)
8154         {
8155         case Utils::SHADER_STAGE_FRAGMENT:
8156         {
8157                 result_sstream << "    result = vec4(0);\n"
8158                                            << "    subroutine1(result);\n"
8159                                                   "    subroutine2(result);\n"
8160                                                   "    result = subroutine3(result) + subroutine4(result);\n";
8161
8162                 break;
8163         }
8164
8165         case Utils::SHADER_STAGE_GEOMETRY:
8166         {
8167                 result_sstream << "    gl_Position = vec4(0);\n"
8168                                                   "    subroutine1(gl_Position);\n"
8169                                                   "    subroutine2(gl_Position);\n"
8170                                                   "    gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n"
8171                                                   "    EmitVertex();\n";
8172
8173                 break;
8174         }
8175
8176         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
8177         {
8178                 result_sstream << "    gl_out[gl_InvocationID].gl_Position = vec4(0);\n"
8179                                                   "    subroutine1(gl_out[gl_InvocationID].gl_Position);\n"
8180                                                   "    subroutine2(gl_out[gl_InvocationID].gl_Position);\n"
8181                                                   "    gl_out[gl_InvocationID].gl_Position = subroutine3(gl_in[0].gl_Position) + "
8182                                                   "subroutine4(gl_in[0].gl_Position);\n";
8183
8184                 break;
8185         }
8186
8187         case Utils::SHADER_STAGE_VERTEX:
8188         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
8189         {
8190                 result_sstream << "    gl_Position = vec4(0);\n"
8191                                                   "    subroutine1(gl_Position);\n"
8192                                                   "    subroutine2(gl_Position);\n"
8193                                                   "    gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n";
8194
8195                 break;
8196         }
8197
8198         default:
8199                 break;
8200         } /* switch (shader_stage) */
8201
8202         result_sstream << "}\n";
8203
8204         return result_sstream.str();
8205 }
8206
8207 /** Initializes all objects required to run the test. */
8208 void FunctionalTest16::initTest()
8209 {
8210         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
8211
8212         for (unsigned int n_id = 0; n_id < 2 /* test program/shader objects */; ++n_id)
8213         {
8214                 const std::string fs_body = getShaderBody(Utils::SHADER_STAGE_FRAGMENT, n_id);
8215                 const std::string gs_body = getShaderBody(Utils::SHADER_STAGE_GEOMETRY, n_id);
8216                 const std::string tc_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_CONTROL, n_id);
8217                 const std::string te_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_EVALUATION, n_id);
8218                 const std::string vs_body = getShaderBody(Utils::SHADER_STAGE_VERTEX, n_id);
8219
8220                 if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */
8221                                                                  DE_NULL,                                                                                                  /* n_xfb_varyings */
8222                                                                  m_vs_ids + n_id, m_tc_ids + n_id, m_te_ids + n_id, m_gs_ids + n_id, m_fs_ids + n_id,
8223                                                                  m_po_ids + n_id))
8224                 {
8225                         m_testCtx.getLog() << tcu::TestLog::Message << "Failed to build test program object, index:"
8226                                                                                                                    "["
8227                                                            << n_id << "]" << tcu::TestLog::EndMessage;
8228
8229                         TCU_FAIL("Failed to build a test program");
8230                 }
8231
8232                 if (m_are_pipeline_objects_supported)
8233                 {
8234                         /* Initialize shader program objects */
8235                         const char* fs_body_raw_ptr = fs_body.c_str();
8236                         const char* gs_body_raw_ptr = gs_body.c_str();
8237                         glw::GLint  link_status[5]  = { GL_FALSE };
8238                         const char* tc_body_raw_ptr = tc_body.c_str();
8239                         const char* te_body_raw_ptr = te_body.c_str();
8240                         const char* vs_body_raw_ptr = vs_body.c_str();
8241
8242                         m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr);
8243                         m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr);
8244                         m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr);
8245                         m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr);
8246                         m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr);
8247                         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed.");
8248
8249                         gl.getProgramiv(m_fs_po_ids[n_id], GL_LINK_STATUS, link_status + 0);
8250                         gl.getProgramiv(m_gs_po_ids[n_id], GL_LINK_STATUS, link_status + 1);
8251                         gl.getProgramiv(m_tc_po_ids[n_id], GL_LINK_STATUS, link_status + 2);
8252                         gl.getProgramiv(m_te_po_ids[n_id], GL_LINK_STATUS, link_status + 3);
8253                         gl.getProgramiv(m_vs_po_ids[n_id], GL_LINK_STATUS, link_status + 4);
8254                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
8255
8256                         if (link_status[0] == GL_FALSE)
8257                                 TCU_FAIL("Fragment shader program failed to link");
8258                         if (link_status[1] == GL_FALSE)
8259                                 TCU_FAIL("Geometry shader program failed to link");
8260                         if (link_status[2] == GL_FALSE)
8261                                 TCU_FAIL("Tessellation control shader program failed to link");
8262                         if (link_status[3] == GL_FALSE)
8263                                 TCU_FAIL("Tessellation evaluation shader program failed to link");
8264                         if (link_status[4] == GL_FALSE)
8265                                 TCU_FAIL("Vertex shader program failed to link");
8266
8267                         /* Initialize pipeline program object */
8268                         gl.genProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id);
8269                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed.");
8270
8271                         gl.useProgramStages(m_pipeline_object_ids[n_id], GL_FRAGMENT_SHADER_BIT, m_fs_po_ids[n_id]);
8272                         gl.useProgramStages(m_pipeline_object_ids[n_id], GL_GEOMETRY_SHADER_BIT, m_gs_po_ids[n_id]);
8273                         gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_CONTROL_SHADER_BIT, m_tc_po_ids[n_id]);
8274                         gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_EVALUATION_SHADER_BIT, m_te_po_ids[n_id]);
8275                         gl.useProgramStages(m_pipeline_object_ids[n_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_id]);
8276                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8277                 }
8278
8279                 /* Retrieve subroutine locations */
8280                 struct _item
8281                 {
8282                         glw::GLuint     po_id;
8283                         _shader_stage& stage;
8284                         glw::GLuint     so_id;
8285                         glw::GLenum     so_type;
8286                 } items[] = {
8287                         { m_po_ids[n_id], m_po_descriptors[n_id].fragment, m_fs_ids[n_id], GL_FRAGMENT_SHADER },
8288                         { m_po_ids[n_id], m_po_descriptors[n_id].geometry, m_gs_ids[n_id], GL_GEOMETRY_SHADER },
8289                         { m_po_ids[n_id], m_po_descriptors[n_id].tess_control, m_tc_ids[n_id], GL_TESS_CONTROL_SHADER },
8290                         { m_po_ids[n_id], m_po_descriptors[n_id].tess_evaluation, m_te_ids[n_id], GL_TESS_EVALUATION_SHADER },
8291                         { m_po_ids[n_id], m_po_descriptors[n_id].vertex, m_vs_ids[n_id], GL_VERTEX_SHADER },
8292
8293                         { m_fs_po_ids[n_id], m_fs_po_descriptors[n_id], m_fs_po_ids[n_id], GL_FRAGMENT_SHADER },
8294                         { m_gs_po_ids[n_id], m_gs_po_descriptors[n_id], m_gs_po_ids[n_id], GL_GEOMETRY_SHADER },
8295                         { m_tc_po_ids[n_id], m_tc_po_descriptors[n_id], m_tc_po_ids[n_id], GL_TESS_CONTROL_SHADER },
8296                         { m_te_po_ids[n_id], m_te_po_descriptors[n_id], m_te_po_ids[n_id], GL_TESS_EVALUATION_SHADER },
8297                         { m_vs_po_ids[n_id], m_vs_po_descriptors[n_id], m_vs_po_ids[n_id], GL_VERTEX_SHADER },
8298                 };
8299                 const unsigned int n_items = sizeof(items) / sizeof(items[0]);
8300
8301                 for (unsigned int n_item = 0; n_item < n_items; ++n_item)
8302                 {
8303                         _item& current_item = items[n_item];
8304
8305                         current_item.stage.function1_index =
8306                                 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function1");
8307                         current_item.stage.function2_index =
8308                                 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function2");
8309                         current_item.stage.function3_index =
8310                                 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function3");
8311                         current_item.stage.function4_index =
8312                                 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function4");
8313                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed.");
8314
8315                         if (current_item.stage.function1_index == GL_INVALID_INDEX ||
8316                                 current_item.stage.function2_index == GL_INVALID_INDEX ||
8317                                 current_item.stage.function3_index == GL_INVALID_INDEX ||
8318                                 current_item.stage.function4_index == GL_INVALID_INDEX)
8319                         {
8320                                 TCU_FAIL("Subroutine name was not recognized.");
8321                         }
8322
8323                         current_item.stage.subroutine1_uniform_location =
8324                                 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine1");
8325                         current_item.stage.subroutine2_uniform_location =
8326                                 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine2");
8327                         current_item.stage.subroutine3_uniform_location =
8328                                 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine3");
8329                         current_item.stage.subroutine4_uniform_location =
8330                                 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine4");
8331                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed.");
8332
8333                         if (current_item.stage.subroutine1_uniform_location == -1 ||
8334                                 current_item.stage.subroutine2_uniform_location == -1 ||
8335                                 current_item.stage.subroutine3_uniform_location == -1 ||
8336                                 current_item.stage.subroutine4_uniform_location == -1)
8337                         {
8338                                 TCU_FAIL("Subroutine uniform name was not recognized.");
8339                         }
8340
8341                         if (m_po_ids[n_id] == current_item.po_id)
8342                         {
8343                                 gl.useProgram(current_item.po_id);
8344                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
8345                         }
8346                         else
8347                         {
8348                                 /* Temporarily bind the program pipeline. */
8349                                 gl.bindProgramPipeline(m_pipeline_object_ids[n_id]);
8350                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed.");
8351                         }
8352
8353                         gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine1_uniform_location,
8354                                                                            &current_item.stage.default_subroutine1_value);
8355                         gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine2_uniform_location,
8356                                                                            &current_item.stage.default_subroutine2_value);
8357                         gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine3_uniform_location,
8358                                                                            &current_item.stage.default_subroutine3_value);
8359                         gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine4_uniform_location,
8360                                                                            &current_item.stage.default_subroutine4_value);
8361                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed.");
8362
8363                         current_item.stage.gl_stage = current_item.so_type;
8364
8365                         if (m_po_ids[n_id] != current_item.po_id)
8366                         {
8367                                 /* Unbind the program pipeline object */
8368                                 gl.bindProgramPipeline(0);
8369                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed.");
8370                         }
8371                 } /* for (all items) */
8372
8373                 /* Make sure the default subroutine choices are valid. */
8374                 verifySubroutineUniformValues(
8375                         TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, /* makes the verification routine use program object descriptor */
8376                         n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES);
8377
8378                 if (m_are_pipeline_objects_supported)
8379                 {
8380                         gl.useProgram(0);
8381                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
8382
8383                         gl.bindProgramPipeline(m_pipeline_object_ids[n_id]);
8384                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed.");
8385                         {
8386                                 verifySubroutineUniformValues(
8387                                         TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT, /* makes the verification routine use pipeline object descriptor */
8388                                         n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES);
8389                         }
8390                         gl.bindProgramPipeline(0);
8391                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed.");
8392                 }
8393         } /* for (both program descriptors) */
8394 }
8395
8396 /** Retrieves IDs of shaders OR shader program objects, depending on which of the two
8397  *  the caller requests for.
8398  *
8399  *  @param retrieve_program_object_shader_ids true if the caller wishes to retrieve shader object IDs,
8400  *                                            false to return shader program IDs.
8401  *  @param n_id                               Index of the program/pipeline object the shaders
8402  *                                            are a part of.
8403  *  @param out_shader_stages                  Deref will be used to store exactly five IDs. Must not
8404  *                                            be NULL.
8405  **/
8406 void FunctionalTest16::getShaderStages(bool retrieve_program_object_shader_ids, const unsigned int& n_id,
8407                                                                            const _shader_stage** out_shader_stages) const
8408 {
8409         if (retrieve_program_object_shader_ids)
8410         {
8411                 out_shader_stages[0] = &m_po_descriptors[n_id].vertex;
8412                 out_shader_stages[1] = &m_po_descriptors[n_id].tess_control;
8413                 out_shader_stages[2] = &m_po_descriptors[n_id].tess_evaluation;
8414                 out_shader_stages[3] = &m_po_descriptors[n_id].geometry;
8415                 out_shader_stages[4] = &m_po_descriptors[n_id].fragment;
8416         }
8417         else
8418         {
8419                 out_shader_stages[0] = m_vs_po_descriptors + n_id;
8420                 out_shader_stages[1] = m_tc_po_descriptors + n_id;
8421                 out_shader_stages[2] = m_te_po_descriptors + n_id;
8422                 out_shader_stages[3] = m_gs_po_descriptors + n_id;
8423                 out_shader_stages[4] = m_fs_po_descriptors + n_id;
8424         }
8425 }
8426
8427 /** Executes test iteration.
8428  *
8429  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
8430  */
8431 tcu::TestNode::IterateResult FunctionalTest16::iterate()
8432 {
8433         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
8434
8435         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
8436         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
8437         {
8438                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
8439         }
8440
8441         m_are_pipeline_objects_supported =
8442                 m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects");
8443
8444         /* Initialize GL objects required to run the test */
8445         initTest();
8446
8447         /* Iterate over both pipelines/programs and verify that calling glUseProgram() /
8448          * glBindProgramPipeline() / glUseProgramStages() resets subroutine uniform configuration.
8449          */
8450         for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case)
8451         {
8452                 if (static_cast<_test_case>(test_case) != TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT &&
8453                         !m_are_pipeline_objects_supported)
8454                 {
8455                         /* Current test case requires GL_ARB_separate_shader_objects support which is
8456                          * unavaiable on the platform that we're testing
8457                          */
8458                         continue;
8459                 }
8460
8461                 for (unsigned int n_object_id = 0; n_object_id < 2; /* pipeline/program objects allocated for the test */
8462                          ++n_object_id)
8463                 {
8464                         /* Verify that currently reported subroutine uniform values are equal to default values */
8465                         if (test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT)
8466                         {
8467                                 gl.useProgram(m_po_ids[n_object_id]);
8468                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed");
8469                         }
8470                         else
8471                         {
8472                                 gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]);
8473                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed");
8474                         }
8475
8476                         verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id,
8477                                                                                   SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES);
8478
8479                         /* Re-configure subroutine uniforms so that they point to different subroutines than
8480                          * the default ones.
8481                          */
8482                         const _shader_stage* stages[5 /* fs+gs+tc+te+vs */] = { DE_NULL };
8483
8484                         getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT,
8485                                                         n_object_id, stages);
8486
8487                         for (unsigned int n_stage = 0; n_stage < 5 /* fs+gs+tc+te+vs stages */; ++n_stage)
8488                         {
8489                                 const _shader_stage& current_stage                               = *(stages[n_stage]);
8490                                 glw::GLuint                      subroutine_configuration[4] = { GL_INVALID_INDEX };
8491
8492                                 subroutine_configuration[0] =
8493                                         (current_stage.default_subroutine1_value == current_stage.function1_index) ?
8494                                                 current_stage.function2_index :
8495                                                 current_stage.function1_index;
8496                                 subroutine_configuration[1] =
8497                                         (current_stage.default_subroutine2_value == current_stage.function1_index) ?
8498                                                 current_stage.function2_index :
8499                                                 current_stage.function1_index;
8500                                 subroutine_configuration[2] =
8501                                         (current_stage.default_subroutine3_value == current_stage.function3_index) ?
8502                                                 current_stage.function4_index :
8503                                                 current_stage.function3_index;
8504                                 subroutine_configuration[3] =
8505                                         (current_stage.default_subroutine4_value == current_stage.function3_index) ?
8506                                                 current_stage.function4_index :
8507                                                 current_stage.function3_index;
8508
8509                                 gl.uniformSubroutinesuiv(current_stage.gl_stage, 4 /* count */, subroutine_configuration);
8510                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed.");
8511                         } /* for (all stages) */
8512
8513                         verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id,
8514                                                                                   SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES);
8515
8516                         /* Execute test case-specific code */
8517                         _shader_stage cached_shader_stage_data;
8518                         bool              stage_reset_status[Utils::SHADER_STAGE_COUNT] = { false, false, false, false, false };
8519                         bool              uses_stage_reset_status                                               = false;
8520
8521                         switch (test_case)
8522                         {
8523                         case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT:
8524                         {
8525                                 /* Switch to a different program object and then back to current PO.
8526                                  * Subroutine uniforms should be back at their default settings, instead of
8527                                  * the ones we've just set.
8528                                  */
8529                                 gl.useProgram(m_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8530                                 gl.useProgram(m_po_ids[n_object_id]);
8531                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed.");
8532
8533                                 break;
8534                         }
8535
8536                         case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT:
8537                         {
8538                                 /* Switch to a different pipeline object and then back to the current one.
8539                                  * Subroutine uniforms should be back at their default settings, instead of
8540                                  * the ones we've just set.
8541                                  */
8542                                 gl.bindProgramPipeline(
8543                                         m_pipeline_object_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8544                                 gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]);
8545                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call(s) failed.");
8546
8547                                 break;
8548                         }
8549
8550                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE:
8551                         {
8552                                 /* Change the fragment shader stage to a different one.
8553                                  *
8554                                  * Note: We also need to update internal descriptor since the subroutine/uniform
8555                                  *       locations may be different between the two programs.
8556                                  */
8557                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT,
8558                                                                         m_fs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8559                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8560
8561                                 cached_shader_stage_data                 = m_fs_po_descriptors[n_object_id];
8562                                 m_fs_po_descriptors[n_object_id] = m_fs_po_descriptors[(n_object_id + 1) % 2];
8563
8564                                 stage_reset_status[Utils::SHADER_STAGE_FRAGMENT] = true;
8565                                 uses_stage_reset_status                                                  = true;
8566
8567                                 break;
8568                         }
8569
8570                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE:
8571                         {
8572                                 /* Change the geometry shader stage to a different one.
8573                                  *
8574                                  * Note: We also need to update internal descriptor since the subroutine/uniform
8575                                  *       locations may be different between the two programs.
8576                                  */
8577                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT,
8578                                                                         m_gs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8579                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8580
8581                                 cached_shader_stage_data                 = m_gs_po_descriptors[n_object_id];
8582                                 m_gs_po_descriptors[n_object_id] = m_gs_po_descriptors[(n_object_id + 1) % 2];
8583
8584                                 stage_reset_status[Utils::SHADER_STAGE_GEOMETRY] = true;
8585                                 uses_stage_reset_status                                                  = true;
8586
8587                                 break;
8588                         }
8589
8590                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE:
8591                         {
8592                                 /* Change the tessellation control shader stage to a different one.
8593                                  *
8594                                  * Note: We also need to update internal descriptor since the subroutine/uniform
8595                                  *       locations may be different between the two programs.
8596                                  */
8597                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT,
8598                                                                         m_tc_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8599                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8600
8601                                 cached_shader_stage_data                 = m_tc_po_descriptors[n_object_id];
8602                                 m_tc_po_descriptors[n_object_id] = m_tc_po_descriptors[(n_object_id + 1) % 2];
8603
8604                                 stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_CONTROL] = true;
8605                                 uses_stage_reset_status                                                                          = true;
8606
8607                                 break;
8608                         }
8609
8610                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE:
8611                         {
8612                                 /* Change the tessellation evaluation shader stage to a different one.
8613                                  *
8614                                  * Note: We also need to update internal descriptor since the subroutine/uniform
8615                                  *       locations may be different between the two programs.
8616                                  */
8617                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT,
8618                                                                         m_te_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8619                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8620
8621                                 cached_shader_stage_data                 = m_te_po_descriptors[n_object_id];
8622                                 m_te_po_descriptors[n_object_id] = m_te_po_descriptors[(n_object_id + 1) % 2];
8623
8624                                 stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_EVALUATION] = true;
8625                                 uses_stage_reset_status                                                                                 = true;
8626
8627                                 break;
8628                         }
8629
8630                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE:
8631                         {
8632                                 /* Change the vertex shader stage to a different one.
8633                                  *
8634                                  * Note: We also need to update internal descriptor since the subroutine/uniform
8635                                  *       locations may be different between the two programs.
8636                                  */
8637                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT,
8638                                                                         m_vs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]);
8639                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8640
8641                                 cached_shader_stage_data                 = m_vs_po_descriptors[n_object_id];
8642                                 m_vs_po_descriptors[n_object_id] = m_vs_po_descriptors[(n_object_id + 1) % 2];
8643
8644                                 stage_reset_status[Utils::SHADER_STAGE_VERTEX] = true;
8645                                 uses_stage_reset_status                                            = true;
8646
8647                                 break;
8648                         }
8649
8650                         default:
8651                         {
8652                                 TCU_FAIL("Unrecognized test case");
8653                         }
8654                         } /* switch (test_case) */
8655
8656                         /* Verify the subroutine uniform values are valid */
8657                         if (!uses_stage_reset_status)
8658                         {
8659                                 verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id,
8660                                                                                           SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES);
8661                         }
8662                         else
8663                         {
8664                                 const _shader_stage* shader_stages[Utils::SHADER_STAGE_COUNT] = { DE_NULL };
8665
8666                                 getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT,
8667                                                                 n_object_id, shader_stages);
8668
8669                                 for (unsigned int n_shader_stage = 0; n_shader_stage < Utils::SHADER_STAGE_COUNT; ++n_shader_stage)
8670                                 {
8671                                         const _shader_stage& current_shader_stage = *(shader_stages[n_shader_stage]);
8672
8673                                         if (stage_reset_status[n_shader_stage])
8674                                         {
8675                                                 verifySubroutineUniformValuesForShaderStage(current_shader_stage,
8676                                                                                                                                         SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES);
8677                                         }
8678                                         else
8679                                         {
8680                                                 verifySubroutineUniformValuesForShaderStage(current_shader_stage,
8681                                                                                                                                         SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES);
8682                                         }
8683                                 } /* for (all shader stages) */
8684                         }
8685
8686                         /* Revert the changes some of the test cases appied */
8687                         switch (test_case)
8688                         {
8689                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE:
8690                         {
8691                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT,
8692                                                                         m_fs_po_ids[n_object_id]);
8693                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8694
8695                                 m_fs_po_descriptors[n_object_id] = cached_shader_stage_data;
8696
8697                                 break;
8698                         }
8699
8700                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE:
8701                         {
8702                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT,
8703                                                                         m_gs_po_ids[n_object_id]);
8704                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8705
8706                                 m_gs_po_descriptors[n_object_id] = cached_shader_stage_data;
8707
8708                                 break;
8709                         }
8710
8711                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE:
8712                         {
8713                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT,
8714                                                                         m_tc_po_ids[n_object_id]);
8715                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8716
8717                                 m_tc_po_descriptors[n_object_id] = cached_shader_stage_data;
8718
8719                                 break;
8720                         }
8721
8722                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE:
8723                         {
8724                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT,
8725                                                                         m_te_po_ids[n_object_id]);
8726                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8727
8728                                 m_te_po_descriptors[n_object_id] = cached_shader_stage_data;
8729
8730                                 break;
8731                         }
8732
8733                         case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE:
8734                         {
8735                                 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_object_id]);
8736                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
8737
8738                                 m_vs_po_descriptors[n_object_id] = cached_shader_stage_data;
8739
8740                                 break;
8741                         }
8742
8743                         default:
8744                                 break;
8745                         } /* switch (test_case) */
8746
8747                 } /* for (all program object descriptors) */
8748
8749                 /* Unbind the program object */
8750                 gl.useProgram(0);
8751                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
8752         } /* for (all test cases) */
8753
8754         if (m_has_test_passed)
8755         {
8756                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
8757         }
8758         else
8759         {
8760                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
8761         }
8762
8763         return STOP;
8764 }
8765
8766 /** Verifies the subroutine uniform values reported by GL implementation. Depending on the test case,
8767  *  it will either query program object stages or separate shader objects.
8768  *
8769  *  @param test_case    Test case the verification is to be performed for.
8770  *  @param n_id         Index of the program/pipeline object to use for the verification
8771  *  @param verification Verification method.
8772  */
8773 void FunctionalTest16::verifySubroutineUniformValues(const _test_case& test_case, const unsigned int& n_id,
8774                                                                                                          const _subroutine_uniform_value_verification& verification)
8775 {
8776         const _shader_stage* stages[] = {
8777                 DE_NULL, /* fragment shader     stage slot */
8778                 DE_NULL, /* geometry shader     stage slot */
8779                 DE_NULL, /* tess control shader stage slot */
8780                 DE_NULL, /* tess eval shader    stage slot */
8781                 DE_NULL  /* vertex shader       stage slot */
8782         };
8783         const unsigned int n_stages = sizeof(stages) / sizeof(stages[0]);
8784
8785         /* Verify that currently reported subroutine uniform values are equal to default values */
8786         getShaderStages(test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, n_id, stages);
8787
8788         for (unsigned int n_stage = 0; n_stage < n_stages; ++n_stage)
8789         {
8790                 const _shader_stage& current_stage = *(stages[n_stage]);
8791
8792                 verifySubroutineUniformValuesForShaderStage(current_stage, verification);
8793         } /* for (all items) */
8794 }
8795
8796 /** Verifies the subroutine uniform values reported by GL implementation for user-specified
8797  *  shader stage. If the verification fails, m_has_test_passed will be set to false.
8798  *
8799  *  @param shader_stage Descriptor of a shader stage that should be used for the process.
8800  *  @param verification Type of verification that should be performed.
8801  *
8802  **/
8803 void FunctionalTest16::verifySubroutineUniformValuesForShaderStage(
8804         const _shader_stage& shader_stage, const _subroutine_uniform_value_verification& verification)
8805 {
8806         const glw::Functions& gl                           = m_context.getRenderContext().getFunctions();
8807         glw::GLuint                       result_values[4] = { 0 };
8808
8809         gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine1_uniform_location, result_values + 0);
8810         gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine2_uniform_location, result_values + 1);
8811         gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine3_uniform_location, result_values + 2);
8812         gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine4_uniform_location, result_values + 3);
8813         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed.");
8814
8815         if (verification == SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES)
8816         {
8817                 if (!((result_values[0] == (GLuint)shader_stage.subroutine1_uniform_location ||
8818                            result_values[0] == (GLuint)shader_stage.subroutine2_uniform_location) &&
8819                           (result_values[1] == (GLuint)shader_stage.subroutine1_uniform_location ||
8820                            result_values[1] == (GLuint)shader_stage.subroutine2_uniform_location) &&
8821                           (result_values[2] == (GLuint)shader_stage.subroutine3_uniform_location ||
8822                            result_values[2] == (GLuint)shader_stage.subroutine4_uniform_location) &&
8823                           (result_values[3] == (GLuint)shader_stage.subroutine3_uniform_location ||
8824                            result_values[3] == (GLuint)shader_stage.subroutine4_uniform_location)))
8825                 {
8826                         m_testCtx.getLog() << tcu::TestLog::Message << "SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES validation failed. "
8827                                                                                                                    "Shader stage:["
8828                                                            << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], "
8829                                                                                                                                                                                                   "expected data:["
8830                                                            << shader_stage.subroutine1_uniform_location << " OR "
8831                                                            << shader_stage.subroutine2_uniform_location << " x 2, "
8832                                                            << shader_stage.subroutine3_uniform_location << " OR "
8833                                                            << shader_stage.subroutine4_uniform_location << " x 2], "
8834                                                                                                                                                            "found data:["
8835                                                            << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", "
8836                                                            << result_values[3] << "]." << tcu::TestLog::EndMessage;
8837
8838                         m_has_test_passed = false;
8839                 }
8840         }
8841         else if (verification == SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES)
8842         {
8843                 if (result_values[0] != shader_stage.default_subroutine1_value ||
8844                         result_values[1] != shader_stage.default_subroutine2_value ||
8845                         result_values[2] != shader_stage.default_subroutine3_value ||
8846                         result_values[3] != shader_stage.default_subroutine4_value)
8847                 {
8848                         m_testCtx.getLog() << tcu::TestLog::Message
8849                                                            << "SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES validation failed. "
8850                                                                   "Shader stage:["
8851                                                            << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], "
8852                                                                                                                                                                                                   "expected data:["
8853                                                            << shader_stage.default_subroutine1_value << ", "
8854                                                            << shader_stage.default_subroutine2_value << ", "
8855                                                            << shader_stage.default_subroutine3_value << ", "
8856                                                            << shader_stage.default_subroutine4_value << "], "
8857                                                                                                                                                         "found data:["
8858                                                            << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", "
8859                                                            << result_values[3] << "]." << tcu::TestLog::EndMessage;
8860
8861                         m_has_test_passed = false;
8862                 }
8863         }
8864         else
8865         {
8866                 DE_ASSERT(verification == SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES);
8867
8868                 if (result_values[0] == shader_stage.default_subroutine1_value ||
8869                         result_values[1] == shader_stage.default_subroutine2_value ||
8870                         result_values[2] == shader_stage.default_subroutine3_value ||
8871                         result_values[3] == shader_stage.default_subroutine4_value)
8872                 {
8873                         m_testCtx.getLog() << tcu::TestLog::Message
8874                                                            << "SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES validation failed. "
8875                                                                   "Shader stage:["
8876                                                            << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], "
8877                                                                                                                                                                                                   "expected data:!["
8878                                                            << shader_stage.default_subroutine1_value << ", "
8879                                                            << shader_stage.default_subroutine2_value << ", "
8880                                                            << shader_stage.default_subroutine3_value << ", "
8881                                                            << shader_stage.default_subroutine4_value << "], "
8882                                                                                                                                                         "found data:["
8883                                                            << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", "
8884                                                            << result_values[3] << "]." << tcu::TestLog::EndMessage;
8885
8886                         m_has_test_passed = false;
8887                 }
8888         }
8889 }
8890
8891 /** Constructor.
8892  *
8893  *  @param context Rendering context.
8894  *
8895  **/
8896 FunctionalTest17::FunctionalTest17(deqp::Context& context)
8897         : TestCase(context, "same_subroutine_and_subroutine_uniform_but_different_type_used_in_all_stages",
8898                            "Creates a program which uses the same subroutine and subroutine uniform "
8899                            "names for every stage (types of subroutines are different in each stage) "
8900                            "and then makes sure that such program compiles and works as expected.")
8901         , m_fbo_id(0)
8902         , m_fs_id(0)
8903         , m_gs_id(0)
8904         , m_has_test_passed(true)
8905         , m_po_id(0)
8906         , m_tc_id(0)
8907         , m_te_id(0)
8908         , m_to_data(DE_NULL)
8909         , m_to_height(4) /* arbitrary value */
8910         , m_to_id(0)
8911         , m_to_width(4) /* arbitrary value */
8912         , m_vao_id(0)
8913         , m_vs_id(0)
8914 {
8915         /* Left blank intentionally */
8916 }
8917
8918 /** Deinitializes all GL objects that may have been created during test execution. */
8919 void FunctionalTest17::deinit()
8920 {
8921         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
8922
8923         if (m_fbo_id != 0)
8924         {
8925                 gl.deleteFramebuffers(1, &m_fbo_id);
8926
8927                 m_fbo_id = 0;
8928         }
8929
8930         if (m_fs_id != 0)
8931         {
8932                 gl.deleteShader(m_fs_id);
8933
8934                 m_fs_id = 0;
8935         }
8936
8937         if (m_gs_id != 0)
8938         {
8939                 gl.deleteShader(m_gs_id);
8940
8941                 m_gs_id = 0;
8942         }
8943
8944         if (m_po_id != 0)
8945         {
8946                 gl.deleteProgram(m_po_id);
8947
8948                 m_po_id = 0;
8949         }
8950
8951         if (m_tc_id != 0)
8952         {
8953                 gl.deleteShader(m_tc_id);
8954
8955                 m_tc_id = 0;
8956         }
8957
8958         if (m_te_id != 0)
8959         {
8960                 gl.deleteShader(m_te_id);
8961
8962                 m_te_id = 0;
8963         }
8964
8965         if (m_to_data != DE_NULL)
8966         {
8967                 delete[] m_to_data;
8968
8969                 m_to_data = DE_NULL;
8970         }
8971
8972         if (m_to_id != 0)
8973         {
8974                 gl.deleteTextures(1, &m_to_id);
8975
8976                 m_to_id = 0;
8977         }
8978
8979         if (m_vao_id != 0)
8980         {
8981                 gl.deleteVertexArrays(1, &m_vao_id);
8982
8983                 m_vao_id = 0;
8984         }
8985
8986         if (m_vs_id != 0)
8987         {
8988                 gl.deleteShader(m_vs_id);
8989
8990                 m_vs_id = 0;
8991         }
8992
8993         /* Restore original GL configuration */
8994         gl.patchParameteri(GL_PATCH_VERTICES, 3);
8995         GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed.");
8996
8997         gl.pixelStorei(GL_PACK_ALIGNMENT, 4);
8998         GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed.");
8999 }
9000
9001 /** Retrieves body of a fragment shader that should be used by the test program.
9002  *
9003  *  @return Requested string.
9004  **/
9005 std::string FunctionalTest17::getFragmentShaderBody() const
9006 {
9007         return "#version 400\n"
9008                    "\n"
9009                    "#extension GL_ARB_shader_subroutine : require\n"
9010                    "\n"
9011                    "in GS_DATA\n"
9012                    "{\n"
9013                    "    vec4 gs_data;\n"
9014                    "    vec4 tc_data;\n"
9015                    "    vec4 te_data;\n"
9016                    "    vec4 vs_data;\n"
9017                    "} gs;\n"
9018                    "\n"
9019                    "out vec4 result;\n"
9020                    "\n"
9021                    "subroutine void subroutineTypeFS(out vec4 result);\n"
9022                    "\n"
9023                    "subroutine(subroutineTypeFS) void subroutine1(out vec4 result)\n"
9024                    "{\n"
9025                    "    result = vec4(5, 6, 7, 8);\n"
9026                    "}\n"
9027                    "\n"
9028                    "subroutine uniform subroutineTypeFS function;\n"
9029                    "\n"
9030                    "void main()\n"
9031                    "{\n"
9032                    "    vec4 fs_data;\n"
9033                    "\n"
9034                    "    function(fs_data);\n"
9035                    "    result = gs.gs_data + gs.tc_data + gs.te_data + gs.vs_data + fs_data;\n"
9036                    "}\n";
9037 }
9038
9039 /** Retrieves body of a geometry shader that should be used by the test program.
9040  *
9041  *  @return Requested string.
9042  **/
9043 std::string FunctionalTest17::getGeometryShaderBody() const
9044 {
9045         return "#version 400\n"
9046                    "\n"
9047                    "#extension GL_ARB_shader_subroutine : require\n"
9048                    "\n"
9049                    "layout(points)                           in;\n"
9050                    "layout(triangle_strip, max_vertices = 4) out;\n"
9051                    "\n"
9052                    "subroutine void subroutineTypeGS(out vec4 result);\n"
9053                    "\n"
9054                    "subroutine(subroutineTypeGS) void subroutine1(out vec4 result)\n"
9055                    "{\n"
9056                    "    result = vec4(4, 5, 6, 7);\n"
9057                    "}\n"
9058                    "\n"
9059                    "subroutine uniform subroutineTypeGS function;\n"
9060                    "\n"
9061                    "in TE_DATA\n"
9062                    "{\n"
9063                    "    vec4 tc_data;\n"
9064                    "    vec4 te_data;\n"
9065                    "    vec4 vs_data;\n"
9066                    "} te[];\n"
9067                    "\n"
9068                    "out GS_DATA\n"
9069                    "{\n"
9070                    "    vec4 gs_data;\n"
9071                    "    vec4 tc_data;\n"
9072                    "    vec4 te_data;\n"
9073                    "    vec4 vs_data;\n"
9074                    "} result;\n"
9075                    "\n"
9076                    "void main()\n"
9077                    "{\n"
9078                    "    function(result.gs_data);\n"
9079                    "    gl_Position    = vec4(1, -1, 0, 1);\n"
9080                    "    result.tc_data = te[0].tc_data;\n"
9081                    "    result.te_data = te[0].te_data;\n"
9082                    "    result.vs_data = te[0].vs_data;\n"
9083                    "    EmitVertex();\n"
9084                    "\n"
9085                    "    function(result.gs_data);\n"
9086                    "    gl_Position    = vec4(-1, -1, 0, 1);\n"
9087                    "    result.tc_data = te[0].tc_data;\n"
9088                    "    result.te_data = te[0].te_data;\n"
9089                    "    result.vs_data = te[0].vs_data;\n"
9090                    "    EmitVertex();\n"
9091                    "\n"
9092                    "    function(result.gs_data);\n"
9093                    "    gl_Position    = vec4(1, 1, 0, 1);\n"
9094                    "    result.tc_data = te[0].tc_data;\n"
9095                    "    result.te_data = te[0].te_data;\n"
9096                    "    result.vs_data = te[0].vs_data;\n"
9097                    "    EmitVertex();\n"
9098                    "\n"
9099                    "    function(result.gs_data);\n"
9100                    "    gl_Position    = vec4(-1, 1, 0, 1);\n"
9101                    "    result.tc_data = te[0].tc_data;\n"
9102                    "    result.te_data = te[0].te_data;\n"
9103                    "    result.vs_data = te[0].vs_data;\n"
9104                    "    EmitVertex();\n"
9105                    "    EndPrimitive();\n"
9106                    "}\n";
9107 }
9108
9109 /** Retrieves body of a tessellation control shader that should be used by the test program.
9110  *
9111  *  @return Requested string.
9112  **/
9113 std::string FunctionalTest17::getTessellationControlShaderBody() const
9114 {
9115         return "#version 400\n"
9116                    "\n"
9117                    "#extension GL_ARB_shader_subroutine : require\n"
9118                    "\n"
9119                    "layout (vertices = 4) out;\n"
9120                    "\n"
9121                    "subroutine void subroutineTypeTC(out vec4 result);\n"
9122                    "\n"
9123                    "subroutine(subroutineTypeTC) void subroutine1(out vec4 result)\n"
9124                    "{\n"
9125                    "    result = vec4(2, 3, 4, 5);\n"
9126                    "}\n"
9127                    "\n"
9128                    "subroutine uniform subroutineTypeTC function;\n"
9129                    "\n"
9130                    "in VS_DATA\n"
9131                    "{\n"
9132                    "    vec4 vs_data;\n"
9133                    "} vs[];\n"
9134                    "\n"
9135                    "out TC_DATA\n"
9136                    "{\n"
9137                    "    vec4 tc_data;\n"
9138                    "    vec4 vs_data;\n"
9139                    "} result[];\n"
9140                    "\n"
9141                    "void main()\n"
9142                    "{\n"
9143                    "    gl_TessLevelInner[0] = 1.0;\n"
9144                    "    gl_TessLevelInner[1] = 1.0;\n"
9145                    "    gl_TessLevelOuter[0] = 1.0;\n"
9146                    "    gl_TessLevelOuter[1] = 1.0;\n"
9147                    "    gl_TessLevelOuter[2] = 1.0;\n"
9148                    "    gl_TessLevelOuter[3] = 1.0;\n"
9149                    "\n"
9150                    "    function(result[gl_InvocationID].tc_data);\n"
9151                    "    result[gl_InvocationID].vs_data = vs[gl_InvocationID].vs_data;\n"
9152                    "}\n";
9153 }
9154
9155 /** Retrieves body of a tessellation evaluation shader that should be used
9156  *  by the test program.
9157  *
9158  *  @return Requested string.
9159  **/
9160 std::string FunctionalTest17::getTessellationEvaluationShaderBody() const
9161 {
9162         return "#version 400\n"
9163                    "\n"
9164                    "#extension GL_ARB_shader_subroutine : require\n"
9165                    "\n"
9166                    "layout (quads, point_mode) in;\n"
9167                    "\n"
9168                    "subroutine void subroutineTypeTE(out vec4 result);\n"
9169                    "\n"
9170                    "subroutine(subroutineTypeTE) void subroutine1(out vec4 result)\n"
9171                    "{\n"
9172                    "    result = vec4(3, 4, 5, 6);\n"
9173                    "}\n"
9174                    "\n"
9175                    "subroutine uniform subroutineTypeTE function;\n"
9176                    "\n"
9177                    "in TC_DATA\n"
9178                    "{\n"
9179                    "    vec4 tc_data;\n"
9180                    "    vec4 vs_data;\n"
9181                    "} tc[];\n"
9182                    "\n"
9183                    "out TE_DATA\n"
9184                    "{\n"
9185                    "    vec4 tc_data;\n"
9186                    "    vec4 te_data;\n"
9187                    "    vec4 vs_data;\n"
9188                    "} result;\n"
9189                    "\n"
9190                    "void main()\n"
9191                    "{\n"
9192                    "    result.vs_data = tc[0].vs_data;\n"
9193                    "    result.tc_data = tc[0].tc_data;\n"
9194                    "    function(result.te_data);\n"
9195                    "}\n";
9196 }
9197
9198 /** Retrieves body of a vertex shader that should be used by the test program.
9199  *
9200  *  @return Requested string.
9201  **/
9202 std::string FunctionalTest17::getVertexShaderBody() const
9203 {
9204         return "#version 400\n"
9205                    "\n"
9206                    "#extension GL_ARB_shader_subroutine : require\n"
9207                    "\n"
9208                    "out VS_DATA\n"
9209                    "{\n"
9210                    "    vec4 vs_data;\n"
9211                    "} result;\n"
9212                    "\n"
9213                    "subroutine void subroutineTypeVS(out vec4 result);\n"
9214                    "\n"
9215                    "subroutine(subroutineTypeVS) void subroutine1(out vec4 result)\n"
9216                    "{\n"
9217                    "    result = vec4(1, 2, 3, 4);\n"
9218                    "}\n"
9219                    "\n"
9220                    "subroutine uniform subroutineTypeVS function;\n"
9221                    "\n"
9222                    "void main()\n"
9223                    "{\n"
9224                    "    function(result.vs_data);\n"
9225                    "}\n";
9226 }
9227
9228 /** Initializes all buffers and GL objects required to run the test. */
9229 void FunctionalTest17::initTest()
9230 {
9231         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
9232
9233         /* Configure GL_PATCH_VERTICES so that TC only takes a single patch vertex */
9234         gl.patchParameteri(GL_PATCH_VERTICES, 1);
9235         GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed.");
9236
9237         /* Generate & bind a VAO */
9238         gl.genVertexArrays(1, &m_vao_id);
9239         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
9240
9241         gl.bindVertexArray(m_vao_id);
9242         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
9243
9244         /* Set up test program object */
9245         std::string fs_body = getFragmentShaderBody();
9246         std::string gs_body = getGeometryShaderBody();
9247         std::string tc_body = getTessellationControlShaderBody();
9248         std::string te_body = getTessellationEvaluationShaderBody();
9249         std::string vs_body = getVertexShaderBody();
9250
9251         if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */
9252                                                          DE_NULL,                                                                                                  /* n_xfb_varyings */
9253                                                          &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id))
9254         {
9255                 TCU_FAIL("Failed to link test program object");
9256         }
9257
9258         /* Set up a texture object that will be used as a color attachment */
9259         gl.genTextures(1, &m_to_id);
9260         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed.");
9261
9262         gl.bindTexture(GL_TEXTURE_2D, m_to_id);
9263         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed.");
9264
9265         gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */
9266                                         GL_RGBA32F, m_to_width, m_to_height);
9267         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed.");
9268
9269         /* Set up FBO */
9270         gl.genFramebuffers(1, &m_fbo_id);
9271         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed.");
9272
9273         gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
9274         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed.");
9275
9276         gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);
9277         GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed.");
9278
9279         /* Make sure glReadPixels() does not return misaligned data */
9280         gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
9281         GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed.");
9282
9283         /* Initialize a buffer that will be used to store rendered data */
9284         m_to_data = new float[m_to_width * m_to_height * 4 /* rgba */];
9285 }
9286
9287 /** Executes test iteration.
9288  *
9289  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
9290  */
9291 tcu::TestNode::IterateResult FunctionalTest17::iterate()
9292 {
9293         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
9294
9295         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
9296         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
9297         {
9298                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
9299         }
9300
9301         initTest();
9302
9303         /* Use the test program to render a full-screen test quad */
9304         gl.useProgram(m_po_id);
9305         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
9306
9307         gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */);
9308         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
9309
9310         /* Read back the data that was rendered */
9311         gl.readPixels(0, /* x */
9312                                   0, /* y */
9313                                   m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_to_data);
9314         GLU_EXPECT_NO_ERROR(gl.getError(), "glReaDPixels() call failed.");
9315
9316         /* Verify the data */
9317         verifyRenderedData();
9318
9319         /** All done */
9320         if (m_has_test_passed)
9321         {
9322                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
9323         }
9324         else
9325         {
9326                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
9327         }
9328
9329         return STOP;
9330 }
9331
9332 /** Verifies the data that have been rendered by the test program.
9333  *
9334  *  It is assumed the rendered data have already been copied to
9335  *  m_to_data.
9336  *
9337  *  If the rendered data is found to be invalid, m_has_test_passed
9338  *  will be set to false.
9339  **/
9340 void FunctionalTest17::verifyRenderedData()
9341 {
9342         const float epsilon                      = 1e-5f;
9343         const float expected_data[4] = { 15.0f, 20.0f, 25.0f, 30.0f };
9344
9345         for (unsigned int y = 0; y < m_to_height && m_has_test_passed; ++y)
9346         {
9347                 const float* row_ptr = m_to_data + y * 4 /* rgba */ * m_to_width;
9348
9349                 for (unsigned int x = 0; x < m_to_width && m_has_test_passed; ++x)
9350                 {
9351                         const float* pixel_ptr = row_ptr + 4 /* rgba */ * x;
9352
9353                         if (de::abs(pixel_ptr[0] - expected_data[0]) > epsilon ||
9354                                 de::abs(pixel_ptr[1] - expected_data[1]) > epsilon ||
9355                                 de::abs(pixel_ptr[2] - expected_data[2]) > epsilon ||
9356                                 de::abs(pixel_ptr[3] - expected_data[3]) > epsilon)
9357                         {
9358                                 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel found at (" << x << ", " << y
9359                                                                    << "): "
9360                                                                           "expected:("
9361                                                                    << expected_data[0] << ", " << expected_data[1] << ", " << expected_data[2] << ", "
9362                                                                    << expected_data[3] << "), found:(" << pixel_ptr[0] << ", " << pixel_ptr[1] << ", "
9363                                                                    << pixel_ptr[2] << ", " << pixel_ptr[3] << ")." << tcu::TestLog::EndMessage;
9364
9365                                 m_has_test_passed = false;
9366                         }
9367                 } /* for (all columns) */
9368         }        /* for (all rows) */
9369 }
9370
9371 /** Constructor.
9372  *
9373  *  @param context Rendering context.
9374  *
9375  **/
9376 FunctionalTest18_19::FunctionalTest18_19(deqp::Context& context)
9377         : TestCase(context, "control_flow_and_returned_subroutine_values_used_as_subroutine_input",
9378                            "Makes sure that calling a subroutine with argument value returned by "
9379                            "another subroutine works correctly. Also checks that subroutine and "
9380                            "subroutine uniforms work as expected when used in connection with control "
9381                            "flow functions.")
9382         , m_has_test_passed(true)
9383         , m_n_points_to_draw(16) /* arbitrary value */
9384         , m_po_id(0)
9385         , m_po_subroutine_divide_by_two_location(GL_INVALID_INDEX)
9386         , m_po_subroutine_multiply_by_four_location(GL_INVALID_INDEX)
9387         , m_po_subroutine_returns_false_location(GL_INVALID_INDEX)
9388         , m_po_subroutine_returns_true_location(GL_INVALID_INDEX)
9389         , m_po_subroutine_uniform_bool_operator1(-1)
9390         , m_po_subroutine_uniform_bool_operator2(-1)
9391         , m_po_subroutine_uniform_vec4_processor1(-1)
9392         , m_po_subroutine_uniform_vec4_processor2(-1)
9393         , m_xfb_bo_id(0)
9394         , m_vao_id(0)
9395         , m_vs_id(0)
9396 {
9397         /* Left blank intentionally */
9398 }
9399
9400 /** De-initializes all GL objects that may have been created during test execution */
9401 void FunctionalTest18_19::deinit()
9402 {
9403         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
9404
9405         if (m_po_id != 0)
9406         {
9407                 gl.deleteProgram(m_po_id);
9408
9409                 m_po_id = 0;
9410         }
9411
9412         if (m_vao_id != 0)
9413         {
9414                 gl.deleteVertexArrays(1, &m_vao_id);
9415
9416                 m_vao_id = 0;
9417         }
9418
9419         if (m_vs_id != 0)
9420         {
9421                 gl.deleteShader(m_vs_id);
9422
9423                 m_vs_id = 0;
9424         }
9425
9426         if (m_xfb_bo_id != 0)
9427         {
9428                 gl.deleteBuffers(1, &m_xfb_bo_id);
9429
9430                 m_xfb_bo_id = 0;
9431         }
9432 }
9433
9434 /** Executes a single test iteration using user-specified properties. If the
9435  *  iterations fails, m_has_test_passed is set to false.
9436  *
9437  *  @param bool_operator1_subroutine_location Location of a subroutine to be assigned to
9438  *                                            bool_operator1 subroutine uniform.
9439  *  @param bool_operator2_subroutine_location Location of a subroutine to be assigned to
9440  *                                            bool_operator2 subroutine uniform.
9441  *  @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to
9442  *                                            vec4_operator1 subroutine uniform.
9443  *  @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to
9444  *                                            vec4_operator2 subroutine uniform.
9445  &**/
9446 void FunctionalTest18_19::executeTest(glw::GLuint bool_operator1_subroutine_location,
9447                                                                           glw::GLuint bool_operator2_subroutine_location,
9448                                                                           glw::GLuint vec4_operator1_subroutine_location,
9449                                                                           glw::GLuint vec4_operator2_subroutine_location)
9450 {
9451         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
9452
9453         /* Set up subroutines */
9454         glw::GLuint subroutine_configuration[4 /* total number of subroutines */] = { 0 };
9455
9456         subroutine_configuration[m_po_subroutine_uniform_bool_operator1]  = bool_operator1_subroutine_location;
9457         subroutine_configuration[m_po_subroutine_uniform_bool_operator2]  = bool_operator2_subroutine_location;
9458         subroutine_configuration[m_po_subroutine_uniform_vec4_processor1] = vec4_operator1_subroutine_location;
9459         subroutine_configuration[m_po_subroutine_uniform_vec4_processor2] = vec4_operator2_subroutine_location;
9460
9461         gl.useProgram(m_po_id);
9462         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed");
9463
9464         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 4 /* count */, subroutine_configuration);
9465         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed");
9466
9467         /* Draw test-specific number of points */
9468         gl.beginTransformFeedback(GL_POINTS);
9469         GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed");
9470         {
9471                 gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw);
9472                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed");
9473         }
9474         gl.endTransformFeedback();
9475         GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed");
9476
9477         /* Map the BO storage into process space */
9478         const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
9479         GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed.");
9480
9481         verifyXFBData(xfb_data_ptr, bool_operator1_subroutine_location, bool_operator2_subroutine_location,
9482                                   vec4_operator1_subroutine_location, vec4_operator2_subroutine_location);
9483
9484         /* Unmap BO storage */
9485         gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
9486         GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");
9487 }
9488
9489 /** Retrieves body of a vertex shader to be used by the test. */
9490 std::string FunctionalTest18_19::getVertexShaderBody() const
9491 {
9492         return "#version 400\n"
9493                    "\n"
9494                    "subroutine bool bool_processor();\n"
9495                    "subroutine vec4 vec4_processor(in vec4 iparam);\n"
9496                    "\n"
9497                    "subroutine(bool_processor) bool returnsFalse()\n"
9498                    "{\n"
9499                    "    return false;\n"
9500                    "}\n"
9501                    "\n"
9502                    "subroutine(bool_processor) bool returnsTrue()\n"
9503                    "{\n"
9504                    "    return true;\n"
9505                    "}\n"
9506                    "\n"
9507                    "subroutine(vec4_processor) vec4 divideByTwo(in vec4 iparam)\n"
9508                    "{\n"
9509                    "    return iparam * vec4(0.5);\n"
9510                    "}\n"
9511                    "\n"
9512                    "subroutine(vec4_processor) vec4 multiplyByFour(in vec4 iparam)\n"
9513                    "{\n"
9514                    "    return iparam * vec4(4.0);\n"
9515                    "}\n"
9516                    "\n"
9517                    "subroutine uniform bool_processor bool_operator1;\n"
9518                    "subroutine uniform bool_processor bool_operator2;\n"
9519                    "subroutine uniform vec4_processor vec4_operator1;\n"
9520                    "subroutine uniform vec4_processor vec4_operator2;\n"
9521                    "\n"
9522                    "out float result;\n"
9523                    "\n"
9524                    "void main()\n"
9525                    "{\n"
9526                    "    if (bool_operator1() )\n"
9527                    "    {\n"
9528                    "        float value = float( (3 * gl_VertexID + 1) * 2);\n"
9529                    "\n"
9530                    "        while (bool_operator1() )\n"
9531                    "        {\n"
9532                    "            value /= float(gl_VertexID + 2);\n"
9533                    "\n"
9534                    "            if (value <= 1.0f) break;\n"
9535                    "        }\n"
9536                    "\n"
9537                    "        result = value;\n"
9538                    "    }\n"
9539                    "    else\n"
9540                    "    {\n"
9541                    "        vec4 value = vec4(gl_VertexID,     gl_VertexID + 1,\n"
9542                    "                          gl_VertexID + 2, gl_VertexID + 3);\n"
9543                    "\n"
9544                    "        switch (gl_VertexID % 2)\n"
9545                    "        {\n"
9546                    "            case 0:\n"
9547                    "            {\n"
9548                    "                for (int iteration = 0; iteration < gl_VertexID && bool_operator2(); ++iteration)\n"
9549                    "                {\n"
9550                    "                    value = vec4_operator2(vec4_operator1(value));\n"
9551                    "                }\n"
9552                    "\n"
9553                    "                break;\n"
9554                    "            }\n"
9555                    "\n"
9556                    "            case 1:\n"
9557                    "            {\n"
9558                    "                for (int iteration = 0; iteration < gl_VertexID * 2; ++iteration)\n"
9559                    "                {\n"
9560                    "                    value = vec4_operator1(vec4_operator2(value));\n"
9561                    "                }\n"
9562                    "\n"
9563                    "                break;\n"
9564                    "            }\n"
9565                    "        }\n"
9566                    "\n"
9567                    "        result = value.x + value.y + value.z + value.w;\n"
9568                    "\n"
9569                    "    }\n"
9570                    "}\n";
9571 }
9572
9573 /** Initializes all GL objects required to run the test. */
9574 void FunctionalTest18_19::initTest()
9575 {
9576         const glw::Functions& gl                  = m_context.getRenderContext().getFunctions();
9577         const char*                       varyings[1] = { "result" };
9578         std::string                       vs_body        = getVertexShaderBody();
9579         const unsigned int      n_varyings  = sizeof(varyings) / sizeof(varyings[0]);
9580
9581         if (!Utils::buildProgram(gl, vs_body, "",                                                 /* tc_body */
9582                                                          "",                                                                      /* te_body */
9583                                                          "",                                                                      /* gs_body */
9584                                                          "",                                                                      /* fs_body */
9585                                                          varyings, n_varyings, &m_vs_id, DE_NULL, /* out_tc_id */
9586                                                          DE_NULL,                                                                 /* out_te_id */
9587                                                          DE_NULL,                                                                 /* out_gs_id */
9588                                                          DE_NULL,                                                                 /* out_fs_id */
9589                                                          &m_po_id))
9590         {
9591                 TCU_FAIL("Failed to build test program object");
9592         }
9593
9594         /* Retrieve subroutine & subroutine uniform locations */
9595         m_po_subroutine_divide_by_two_location  = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "divideByTwo");
9596         m_po_subroutine_multiply_by_four_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "multiplyByFour");
9597         m_po_subroutine_returns_false_location  = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsFalse");
9598         m_po_subroutine_returns_true_location    = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsTrue");
9599         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed");
9600
9601         if (m_po_subroutine_divide_by_two_location == GL_INVALID_INDEX ||
9602                 m_po_subroutine_multiply_by_four_location == GL_INVALID_INDEX ||
9603                 m_po_subroutine_returns_false_location == GL_INVALID_INDEX ||
9604                 m_po_subroutine_returns_true_location == GL_INVALID_INDEX)
9605         {
9606                 TCU_FAIL("glGetSubroutineIndex() returned GL_INVALID_INDEX for a valid subroutine");
9607         }
9608
9609         m_po_subroutine_uniform_bool_operator1 =
9610                 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator1");
9611         m_po_subroutine_uniform_bool_operator2 =
9612                 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator2");
9613         m_po_subroutine_uniform_vec4_processor1 =
9614                 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator1");
9615         m_po_subroutine_uniform_vec4_processor2 =
9616                 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator2");
9617         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed");
9618
9619         if (m_po_subroutine_uniform_bool_operator1 == -1 || m_po_subroutine_uniform_bool_operator2 == -1 ||
9620                 m_po_subroutine_uniform_vec4_processor1 == -1 || m_po_subroutine_uniform_vec4_processor2 == -1)
9621         {
9622                 TCU_FAIL("glGetSubroutineUniformLocation() returned -1 for an active subroutine uniform");
9623         }
9624
9625         /* Set up XFB BO */
9626         const unsigned int bo_size = static_cast<unsigned int>(sizeof(float) * m_n_points_to_draw);
9627
9628         gl.genBuffers(1, &m_xfb_bo_id);
9629         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");
9630
9631         gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id);
9632         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");
9633
9634         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id);
9635         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");
9636
9637         gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bo_size, DE_NULL /* data */, GL_STATIC_COPY);
9638         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");
9639
9640         /* Set up a VAO */
9641         gl.genVertexArrays(1, &m_vao_id);
9642         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
9643
9644         gl.bindVertexArray(m_vao_id);
9645         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
9646 }
9647
9648 /** Executes test iteration.
9649  *
9650  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
9651  */
9652 tcu::TestNode::IterateResult FunctionalTest18_19::iterate()
9653 {
9654         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
9655         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
9656         {
9657                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
9658         }
9659
9660         /* Initialize all GL objects required to run the test */
9661         initTest();
9662
9663         /* Iterate over all subroutine permutations */
9664         const glw::GLuint subroutine_bool_operators[] = { m_po_subroutine_returns_false_location,
9665                                                                                                           m_po_subroutine_returns_true_location };
9666         const unsigned int n_subroutine_bool_operators =
9667                 sizeof(subroutine_bool_operators) / sizeof(subroutine_bool_operators[0]);
9668
9669         const glw::GLuint subroutine_vec4_operators[] = { m_po_subroutine_divide_by_two_location,
9670                                                                                                           m_po_subroutine_multiply_by_four_location };
9671         const unsigned int n_subroutine_vec4_operators =
9672                 sizeof(subroutine_vec4_operators) / sizeof(subroutine_vec4_operators[0]);
9673
9674         for (unsigned int n_subroutine_uniform_bool_operator1 = 0;
9675                  n_subroutine_uniform_bool_operator1 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator1)
9676         {
9677                 for (unsigned int n_subroutine_uniform_bool_operator2 = 0;
9678                          n_subroutine_uniform_bool_operator2 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator2)
9679                 {
9680                         for (unsigned int n_subroutine_uniform_vec4_operator1 = 0;
9681                                  n_subroutine_uniform_vec4_operator1 < n_subroutine_vec4_operators;
9682                                  ++n_subroutine_uniform_vec4_operator1)
9683                         {
9684                                 for (unsigned int n_subroutine_uniform_vec4_operator2 = 0;
9685                                          n_subroutine_uniform_vec4_operator2 < n_subroutine_vec4_operators;
9686                                          ++n_subroutine_uniform_vec4_operator2)
9687                                 {
9688                                         executeTest(subroutine_bool_operators[n_subroutine_uniform_bool_operator1],
9689                                                                 subroutine_bool_operators[n_subroutine_uniform_bool_operator2],
9690                                                                 subroutine_vec4_operators[n_subroutine_uniform_vec4_operator1],
9691                                                                 subroutine_vec4_operators[n_subroutine_uniform_vec4_operator2]);
9692                                 } /* for (all subroutine vec4 operator subroutines used for processor2) */
9693                         }        /* for (all subroutine vec4 operator subroutines used for processor1) */
9694                 }                 /* for (all subroutine bool operator subroutines used for operator2) */
9695         }                         /* for (all subroutine bool operator subroutines used for operator1) */
9696
9697         /* All done */
9698         if (m_has_test_passed)
9699         {
9700                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
9701         }
9702         else
9703         {
9704                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
9705         }
9706
9707         return STOP;
9708 }
9709
9710 /** Divides input argument by two. The result value is returned to the
9711  *  caller.
9712  *
9713  *  @param data Input value.
9714  *
9715  *  @return As per description.
9716  **/
9717 tcu::Vec4 FunctionalTest18_19::vec4operator_div2(tcu::Vec4 data)
9718 {
9719         return data * 0.5f;
9720 }
9721
9722 /** Multiplies input argument by four. The result value is returned to the
9723  *  caller.
9724  *
9725  *  @param data Input value.
9726  *
9727  *  @return As per description.
9728  **/
9729 tcu::Vec4 FunctionalTest18_19::vec4operator_mul4(tcu::Vec4 data)
9730 {
9731         return data * 4.0f;
9732 }
9733
9734 /** Verifies data XFBed out by the vertex shader. It is assumed the subroutines were configured
9735  *  as per passed arguments, prior to the draw call.
9736  *
9737  *  If the result data is found to be invalid, m_has_test_passed is set to false.
9738  *
9739  *  @param data                               XFBed data.
9740  *  @param bool_operator1_subroutine_location Location of a subroutine to be assigned to
9741  *                                            bool_operator1 subroutine uniform.
9742  *  @param bool_operator2_subroutine_location Location of a subroutine to be assigned to
9743  *                                            bool_operator2 subroutine uniform.
9744  *  @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to
9745  *                                            vec4_operator1 subroutine uniform.
9746  *  @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to
9747  *                                            vec4_operator2 subroutine uniform.
9748  */
9749 void FunctionalTest18_19::verifyXFBData(const glw::GLvoid* data, glw::GLuint bool_operator1_subroutine_location,
9750                                                                                 glw::GLuint bool_operator2_subroutine_location,
9751                                                                                 glw::GLuint vec4_operator1_subroutine_location,
9752                                                                                 glw::GLuint vec4_operator2_subroutine_location)
9753 {
9754         bool                            bool_operator1_result = false;
9755         bool                            bool_operator2_result = false;
9756         const float                     epsilon                           = 1e-5f;
9757         PFNVEC4OPERATORPROC pVec4Operator1                = NULL;
9758         PFNVEC4OPERATORPROC pVec4Operator2                = NULL;
9759         const glw::GLfloat* traveller_ptr                 = (const glw::GLfloat*)data;
9760
9761         bool_operator1_result = (bool_operator1_subroutine_location == m_po_subroutine_returns_true_location);
9762         bool_operator2_result = (bool_operator2_subroutine_location == m_po_subroutine_returns_true_location);
9763         pVec4Operator1            = (vec4_operator1_subroutine_location == m_po_subroutine_divide_by_two_location) ?
9764                                                  vec4operator_div2 :
9765                                                  vec4operator_mul4;
9766         pVec4Operator2 = (vec4_operator2_subroutine_location == m_po_subroutine_divide_by_two_location) ?
9767                                                  vec4operator_div2 :
9768                                                  vec4operator_mul4;
9769
9770         for (unsigned int n_vertex = 0; n_vertex < m_n_points_to_draw; ++n_vertex)
9771         {
9772                 float expected_value = 0.0f;
9773
9774                 if (bool_operator1_result)
9775                 {
9776                         float value = float((3 * n_vertex + 1) * 2);
9777
9778                         while (bool_operator1_result)
9779                         {
9780                                 value /= float(n_vertex + 2);
9781
9782                                 if (value <= 1.0f)
9783                                         break;
9784                         }
9785
9786                         expected_value = value;
9787                 }
9788                 else
9789                 {
9790                         tcu::Vec4 value((float)n_vertex, (float)n_vertex + 1, (float)n_vertex + 2, (float)n_vertex + 3);
9791
9792                         switch (n_vertex % 2)
9793                         {
9794                         case 0:
9795                         {
9796                                 for (unsigned int iteration = 0; iteration < n_vertex && bool_operator2_result; ++iteration)
9797                                 {
9798                                         value = pVec4Operator2(pVec4Operator1(value));
9799                                 }
9800
9801                                 break;
9802                         }
9803
9804                         case 1:
9805                         {
9806                                 for (unsigned int iteration = 0; iteration < n_vertex * 2; ++iteration)
9807                                 {
9808                                         value = pVec4Operator1(pVec4Operator2(value));
9809                                 }
9810
9811                                 break;
9812                         }
9813                         } /* switch (n_vertex % 2) */
9814
9815                         expected_value = value.x() + value.y() + value.z() + value.w();
9816                 }
9817
9818                 if (de::abs(expected_value - *traveller_ptr) > epsilon)
9819                 {
9820                         m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data was found to be invalid at index [" << n_vertex
9821                                                            << "]"
9822                                                                   "for the following subroutine location configuration:"
9823                                                                   " bool_operator1_subroutine_location:["
9824                                                            << bool_operator1_subroutine_location << "]"
9825                                                                                                                                                 " bool_operator2_subroutine_location:["
9826                                                            << bool_operator2_subroutine_location << "]"
9827                                                                                                                                                 " vec4_operator1_subroutine_location:["
9828                                                            << vec4_operator1_subroutine_location << "]"
9829                                                                                                                                                 " vec4_operator2_subroutine_location:["
9830                                                            << vec4_operator2_subroutine_location << "];"
9831                                                                                                                                                 " expected data:"
9832                                                            << expected_value << ", found:" << *traveller_ptr << tcu::TestLog::EndMessage;
9833
9834                         m_has_test_passed = false;
9835                 }
9836
9837                 ++traveller_ptr;
9838         } /* for (all drawn points) */
9839 }
9840
9841 /* Constants used by FunctionalTest20_21 */
9842 const GLuint FunctionalTest20_21::m_n_shared_contexts                              = 4;
9843 const GLuint FunctionalTest20_21::m_fragment_stage_index                           = 0;
9844 const GLuint FunctionalTest20_21::m_geometry_stage_index                           = 1;
9845 const GLuint FunctionalTest20_21::m_tesselation_control_stage_index     = 2;
9846 const GLuint FunctionalTest20_21::m_tesselation_evaluation_stage_index = 3;
9847 const GLuint FunctionalTest20_21::m_vertex_stage_index                             = 4;
9848
9849 /** Set subroutine indices, indices are taken from one of two sets according to provided <bit_field>
9850  *
9851  * @param bit_field          Selects source of of index for each stage
9852  * @param subroutine_indices Array of two indices sets
9853  **/
9854 void FunctionalTest20_21::subroutineUniformSet::set(GLuint bit_field, const subroutineUniformSet subroutine_indices[2])
9855 {
9856         GLuint vertex_stage                                     = ((bit_field & (0x01 << 0)) >> 0);
9857         GLuint tesselation_control_stage        = ((bit_field & (0x01 << 1)) >> 1);
9858         GLuint tesselation_evaluation_stage = ((bit_field & (0x01 << 2)) >> 2);
9859         GLuint geometry_stage                           = ((bit_field & (0x01 << 3)) >> 3);
9860         GLuint fragment_stage                           = ((bit_field & (0x01 << 4)) >> 4);
9861
9862         m_vertex_shader_stage = subroutine_indices[vertex_stage].m_vertex_shader_stage;
9863         m_tesselation_control_shader_stage =
9864                 subroutine_indices[tesselation_control_stage].m_tesselation_control_shader_stage;
9865         m_tesselation_evaluation_shader_stage =
9866                 subroutine_indices[tesselation_evaluation_stage].m_tesselation_evaluation_shader_stage;
9867         m_geometry_shader_stage = subroutine_indices[geometry_stage].m_geometry_shader_stage;
9868         m_fragment_shader_stage = subroutine_indices[fragment_stage].m_fragment_shader_stage;
9869 }
9870
9871 /** Negated comparison of two sets
9872  *
9873  * @param arg Instance that will be compared to this
9874  *
9875  * @return false when both objects are equal, true otherwise
9876  **/
9877 bool FunctionalTest20_21::subroutineUniformSet::operator!=(const subroutineUniformSet& arg) const
9878 {
9879         if ((arg.m_vertex_shader_stage != m_vertex_shader_stage) ||
9880                 (arg.m_tesselation_control_shader_stage != m_tesselation_control_shader_stage) ||
9881                 (arg.m_tesselation_evaluation_shader_stage != m_tesselation_evaluation_shader_stage) ||
9882                 (arg.m_geometry_shader_stage != m_geometry_shader_stage) ||
9883                 (arg.m_fragment_shader_stage != m_fragment_shader_stage))
9884         {
9885                 return true;
9886         }
9887
9888         return false;
9889 }
9890
9891 /** Constructor.
9892  *
9893  *  @param context Rendering context.
9894  *
9895  **/
9896 FunctionalTest20_21::FunctionalTest20_21(deqp::Context& context)
9897         : TestCase(context, "multiple_contexts",
9898                            "Verifies that shader uniforms are preserved when rendering context is switched.")
9899 {
9900         for (GLuint i = 0; i < m_n_shared_contexts + 1; ++i)
9901         {
9902                 m_program_pipelines[i] = 0;
9903         }
9904
9905         for (GLuint i = 0; i < m_n_shared_contexts; ++i)
9906         {
9907                 m_shared_contexts[i] = 0;
9908         }
9909 }
9910
9911 /** Deinitializes all GL objects that may have been created during
9912  *  test execution.
9913  **/
9914 void FunctionalTest20_21::deinit()
9915 {
9916         /* GL entry points */
9917         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
9918
9919         for (GLuint i = 0; i < m_n_shared_contexts + 1; ++i)
9920         {
9921                 if (0 != m_program_pipelines[i])
9922                 {
9923                         gl.deleteProgramPipelines(1, &m_program_pipelines[i]);
9924                         m_program_pipelines[i] = 0;
9925                 }
9926         }
9927
9928         for (GLuint i = 0; i < m_n_shared_contexts; ++i)
9929         {
9930                 if (0 != m_shared_contexts[i])
9931                 {
9932                         delete m_shared_contexts[i];
9933                         m_shared_contexts[i] = 0;
9934                 }
9935         }
9936
9937         m_context.getRenderContext().makeCurrent();
9938 }
9939
9940 /** Executes test iteration.
9941  *
9942  *  @return Returns STOP
9943  */
9944 tcu::TestNode::IterateResult FunctionalTest20_21::iterate()
9945 {
9946         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
9947         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
9948         {
9949                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
9950         }
9951
9952         /* Test cases, values stored here are used as bit fields */
9953         static const GLuint test_cases[][m_n_shared_contexts + 1] = {
9954                 { 0, 1, 2, 3, 4 },              { 1, 2, 3, 4, 0 },              { 2, 3, 4, 0, 1 },              { 3, 4, 0, 1, 2 },
9955                 { 4, 0, 1, 2, 3 },              { 27, 28, 29, 30, 31 }, { 28, 29, 30, 31, 27 }, { 29, 30, 31, 27, 28 },
9956                 { 30, 31, 27, 28, 29 }, { 31, 27, 28, 29, 30 },
9957         };
9958         static const GLuint n_test_cases = sizeof(test_cases) / sizeof(test_cases[0]);
9959
9960         /* Prepare contexts */
9961         initSharedContexts();
9962
9963         /* Test result */
9964         bool result = true;
9965
9966         /* Program pointers */
9967         Utils::program* program_pointers[5];
9968
9969         /* Test monolithic program */
9970         {
9971                 /* Prepare program */
9972                 Utils::program program(m_context);
9973
9974                 program_pointers[m_fragment_stage_index] = &program;
9975
9976                 prepareProgram(program_pointers, false);
9977
9978                 /* Execute test */
9979                 if (false == testProgram(program_pointers, false, test_cases, n_test_cases))
9980                 {
9981                         m_context.getTestContext().getLog() << tcu::TestLog::Message
9982                                                                                                 << "Last error message was caused by monolithic program."
9983                                                                                                 << tcu::TestLog::EndMessage;
9984
9985                         result = false;
9986                 }
9987         }
9988
9989         /* Test separable programs */
9990         if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects"))
9991         {
9992                 /* Prepare programs */
9993                 Utils::program vertex_program(m_context);
9994                 Utils::program tesselation_control_program(m_context);
9995                 Utils::program tesselation_evaluation_program(m_context);
9996                 Utils::program geometry_program(m_context);
9997                 Utils::program fragment_program(m_context);
9998
9999                 program_pointers[m_fragment_stage_index]                           = &fragment_program;
10000                 program_pointers[m_geometry_stage_index]                           = &geometry_program;
10001                 program_pointers[m_tesselation_control_stage_index]     = &tesselation_control_program;
10002                 program_pointers[m_tesselation_evaluation_stage_index] = &tesselation_evaluation_program;
10003                 program_pointers[m_vertex_stage_index]                             = &vertex_program;
10004
10005                 prepareProgram(program_pointers, true);
10006
10007                 /* Execute test */
10008                 if (false == testProgram(program_pointers, true, test_cases, n_test_cases))
10009                 {
10010                         m_context.getTestContext().getLog() << tcu::TestLog::Message
10011                                                                                                 << "Last error message was caused by separable program."
10012                                                                                                 << tcu::TestLog::EndMessage;
10013                         result = false;
10014                 }
10015         }
10016
10017         /* All done */
10018         if (true == result)
10019         {
10020                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
10021         }
10022         else
10023         {
10024                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
10025         }
10026
10027         return tcu::TestNode::STOP;
10028 }
10029
10030 /** Query state of subroutine uniforms of current program/pipeline
10031  *
10032  * @param set Storage for results
10033  **/
10034 void FunctionalTest20_21::captureCurrentSubroutineSet(subroutineUniformSet& set)
10035 {
10036         /* GL entry points */
10037         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
10038
10039         /* Fragment */
10040         gl.getUniformSubroutineuiv(GL_FRAGMENT_SHADER, m_subroutine_uniform_locations.m_fragment_shader_stage,
10041                                                            &set.m_fragment_shader_stage);
10042         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
10043
10044         /* Geometry */
10045         gl.getUniformSubroutineuiv(GL_GEOMETRY_SHADER, m_subroutine_uniform_locations.m_geometry_shader_stage,
10046                                                            &set.m_geometry_shader_stage);
10047         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
10048
10049         /* Tess ctrl */
10050         gl.getUniformSubroutineuiv(GL_TESS_CONTROL_SHADER,
10051                                                            m_subroutine_uniform_locations.m_tesselation_control_shader_stage,
10052                                                            &set.m_tesselation_control_shader_stage);
10053         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
10054
10055         /* Tess eval */
10056         gl.getUniformSubroutineuiv(GL_TESS_EVALUATION_SHADER,
10057                                                            m_subroutine_uniform_locations.m_tesselation_evaluation_shader_stage,
10058                                                            &set.m_tesselation_evaluation_shader_stage);
10059         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
10060
10061         /* Vertex */
10062         gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_subroutine_uniform_locations.m_vertex_shader_stage,
10063                                                            &set.m_vertex_shader_stage);
10064         GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv");
10065 }
10066
10067 /** Get shaders' source code
10068  *
10069  * @param out_vertex_shader_code                 Vertex source code
10070  * @param out_tesselation_control_shader_code    Tess ctrl source code
10071  * @param out_tesselation_evaluation_shader_code Tess eval source code
10072  * @param out_geometry_shader_code               Geometry source code
10073  * @param out_fragment_shader_code               Fragment source code
10074  **/
10075 void FunctionalTest20_21::getShaders(const glw::GLchar*& out_vertex_shader_code,
10076                                                                          const glw::GLchar*& out_tesselation_control_shader_code,
10077                                                                          const glw::GLchar*& out_tesselation_evaluation_shader_code,
10078                                                                          const glw::GLchar*& out_geometry_shader_code,
10079                                                                          const glw::GLchar*& out_fragment_shader_code)
10080 {
10081         static const GLchar* vertex_shader_code = "#version 400 core\n"
10082                                                                                           "#extension GL_ARB_shader_subroutine : require\n"
10083                                                                                           "\n"
10084                                                                                           "precision highp float;\n"
10085                                                                                           "\n"
10086                                                                                           "// Subroutine type\n"
10087                                                                                           "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
10088                                                                                           "\n"
10089                                                                                           "// Subroutine definition\n"
10090                                                                                           "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
10091                                                                                           "{\n"
10092                                                                                           "    return left + right;\n"
10093                                                                                           "}\n"
10094                                                                                           "\n"
10095                                                                                           "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
10096                                                                                           "{\n"
10097                                                                                           "    return left * right;\n"
10098                                                                                           "}\n"
10099                                                                                           "\n"
10100                                                                                           "// Sub routine uniform\n"
10101                                                                                           "subroutine uniform routine_type routine;\n"
10102                                                                                           "\n"
10103                                                                                           "// Input data\n"
10104                                                                                           "uniform vec4 uni_vs_left;\n"
10105                                                                                           "uniform vec4 uni_vs_right;\n"
10106                                                                                           "\n"
10107                                                                                           "// Output\n"
10108                                                                                           "out vec4 vs_tcs_result;\n"
10109                                                                                           "\n"
10110                                                                                           "void main()\n"
10111                                                                                           "{\n"
10112                                                                                           "    vs_tcs_result = routine(uni_vs_left, uni_vs_right);\n"
10113                                                                                           "}\n"
10114                                                                                           "\n";
10115
10116         static const GLchar* tesselation_control_shader_code =
10117                 "#version 400 core\n"
10118                 "#extension GL_ARB_shader_subroutine : require\n"
10119                 "\n"
10120                 "precision highp float;\n"
10121                 "\n"
10122                 "layout(vertices = 1) out;\n"
10123                 "\n"
10124                 "// Subroutine type\n"
10125                 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
10126                 "\n"
10127                 "// Subroutine definition\n"
10128                 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
10129                 "{\n"
10130                 "    return left + right;\n"
10131                 "}\n"
10132                 "\n"
10133                 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
10134                 "{\n"
10135                 "    return left * right;\n"
10136                 "}\n"
10137                 "\n"
10138                 "// Sub routine uniform\n"
10139                 "subroutine uniform routine_type routine;\n"
10140                 "\n"
10141                 "// Input data\n"
10142                 "uniform vec4 uni_tcs_left;\n"
10143                 "uniform vec4 uni_tcs_right;\n"
10144                 "\n"
10145                 "in vec4 vs_tcs_result[];\n"
10146                 "\n"
10147                 "// Output\n"
10148                 "out vec4 tcs_tes_result[];\n"
10149                 "\n"
10150                 "void main()\n"
10151                 "{\n"
10152                 "    gl_TessLevelOuter[0] = 1.0;\n"
10153                 "    gl_TessLevelOuter[1] = 1.0;\n"
10154                 "    gl_TessLevelOuter[2] = 1.0;\n"
10155                 "    gl_TessLevelOuter[3] = 1.0;\n"
10156                 "    gl_TessLevelInner[0] = 1.0;\n"
10157                 "    gl_TessLevelInner[1] = 1.0;\n"
10158                 "\n"
10159                 "    tcs_tes_result[gl_InvocationID] = routine(uni_tcs_left, uni_tcs_right) + vs_tcs_result[gl_InvocationID];\n"
10160                 "}\n"
10161                 "\n";
10162
10163         static const GLchar* tesselation_evaluation_shader_code =
10164                 "#version 400 core\n"
10165                 "#extension GL_ARB_shader_subroutine : require\n"
10166                 "\n"
10167                 "precision highp float;\n"
10168                 "\n"
10169                 "layout(isolines, point_mode) in;\n"
10170                 "\n"
10171                 "// Subroutine type\n"
10172                 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
10173                 "\n"
10174                 "// Subroutine definition\n"
10175                 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
10176                 "{\n"
10177                 "    return left + right;\n"
10178                 "}\n"
10179                 "\n"
10180                 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
10181                 "{\n"
10182                 "    return left * right;\n"
10183                 "}\n"
10184                 "\n"
10185                 "// Sub routine uniform\n"
10186                 "subroutine uniform routine_type routine;\n"
10187                 "\n"
10188                 "// Input data\n"
10189                 "uniform vec4 uni_tes_left;\n"
10190                 "uniform vec4 uni_tes_right;\n"
10191                 "\n"
10192                 "in vec4 tcs_tes_result[];\n"
10193                 "\n"
10194                 "// Output\n"
10195                 "out vec4 tes_gs_result;\n"
10196                 "\n"
10197                 "void main()\n"
10198                 "{\n"
10199                 "    tes_gs_result = routine(uni_tes_left, uni_tes_right) + tcs_tes_result[0];\n"
10200                 "}\n"
10201                 "\n";
10202
10203         static const GLchar* geometry_shader_code =
10204                 "#version 400 core\n"
10205                 "#extension GL_ARB_shader_subroutine : require\n"
10206                 "\n"
10207                 "precision highp float;\n"
10208                 "\n"
10209                 "layout(points)                   in;\n"
10210                 "layout(points, max_vertices = 1) out;\n"
10211                 "\n"
10212                 "// Subroutine type\n"
10213                 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
10214                 "\n"
10215                 "// Subroutine definition\n"
10216                 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
10217                 "{\n"
10218                 "    return left + right;\n"
10219                 "}\n"
10220                 "\n"
10221                 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
10222                 "{\n"
10223                 "    return left * right;\n"
10224                 "}\n"
10225                 "\n"
10226                 "// Sub routine uniform\n"
10227                 "subroutine uniform routine_type routine;\n"
10228                 "\n"
10229                 "// Input data\n"
10230                 "uniform vec4 uni_gs_left;\n"
10231                 "uniform vec4 uni_gs_right;\n"
10232                 "\n"
10233                 "in vec4 tes_gs_result[];\n"
10234                 "\n"
10235                 "// Output\n"
10236                 "out vec4 gs_fs_result;\n"
10237                 "\n"
10238                 "void main()\n"
10239                 "{\n"
10240                 "    gs_fs_result = routine(uni_gs_left, uni_gs_right) + tes_gs_result[0];\n"
10241                 "}\n"
10242                 "\n";
10243
10244         static const GLchar* fragmenty_shader_code =
10245                 "#version 400 core\n"
10246                 "#extension GL_ARB_shader_subroutine : require\n"
10247                 "\n"
10248                 "precision highp float;\n"
10249                 "\n"
10250                 "// Subroutine type\n"
10251                 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n"
10252                 "\n"
10253                 "// Subroutine definition\n"
10254                 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n"
10255                 "{\n"
10256                 "    return left + right;\n"
10257                 "}\n"
10258                 "\n"
10259                 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n"
10260                 "{\n"
10261                 "    return left * right;\n"
10262                 "}\n"
10263                 "\n"
10264                 "// Sub routine uniform\n"
10265                 "subroutine uniform routine_type routine;\n"
10266                 "\n"
10267                 "// Input data\n"
10268                 "uniform vec4 uni_fs_left;\n"
10269                 "uniform vec4 uni_fs_right;\n"
10270                 "\n"
10271                 "in vec4 gs_fs_result;\n"
10272                 "\n"
10273                 "// Output\n"
10274                 "out vec4 fs_out_result;\n"
10275                 "\n"
10276                 "void main()\n"
10277                 "{\n"
10278                 "    fs_out_result = routine(uni_fs_left, uni_fs_right) + gs_fs_result;\n"
10279                 "}\n"
10280                 "\n";
10281
10282         out_vertex_shader_code                             = vertex_shader_code;
10283         out_tesselation_control_shader_code     = tesselation_control_shader_code;
10284         out_tesselation_evaluation_shader_code = tesselation_evaluation_shader_code;
10285         out_geometry_shader_code                           = geometry_shader_code;
10286         out_fragment_shader_code                           = fragmenty_shader_code;
10287 }
10288
10289 /** Create <m_n_shared_contexts> shared contexts
10290  *
10291  **/
10292 void FunctionalTest20_21::initSharedContexts()
10293 {
10294         for (GLuint i = 0; i < m_n_shared_contexts; ++i)
10295         {
10296                 m_shared_contexts[i] = m_context.createSharedContext();
10297         }
10298 }
10299
10300 /** Prepare program(s)
10301  *
10302  * @param programs     An array of 5 programs' pointers. If monolithic program is prepared that only index m_fragment_stage_index should be initialized, otherwise all 5
10303  * @param is_separable Select if monolithic or separable programs should be prepared
10304  **/
10305 void FunctionalTest20_21::prepareProgram(Utils::program** programs, bool is_separable)
10306 {
10307         /* Get shader sources */
10308         const GLchar* vertex_shader_code;
10309         const GLchar* tesselation_control_shader_code;
10310         const GLchar* tesselation_evaluation_shader_code;
10311         const GLchar* geometry_shader_code;
10312         const GLchar* fragmenty_shader_code;
10313
10314         getShaders(vertex_shader_code, tesselation_control_shader_code, tesselation_evaluation_shader_code,
10315                            geometry_shader_code, fragmenty_shader_code);
10316
10317         /* Subroutines and uniform names */
10318         static const GLchar* subroutine_names[] = { "add", "multiply" };
10319         static const GLuint  n_subroutines              = sizeof(subroutine_names) / sizeof(subroutine_names[0]);
10320
10321         static const GLchar* subroutine_uniform_name = "routine";
10322
10323         /* Build program */
10324         if (false == is_separable)
10325         {
10326                 programs[0]->build(0 /* compute shader source */, fragmenty_shader_code, geometry_shader_code,
10327                                                    tesselation_control_shader_code, tesselation_evaluation_shader_code, vertex_shader_code,
10328                                                    0 /* varying_names */, 0 /* n_varying_names */);
10329
10330                 programs[m_geometry_stage_index]                           = programs[m_fragment_stage_index];
10331                 programs[m_tesselation_control_stage_index]     = programs[m_fragment_stage_index];
10332                 programs[m_tesselation_evaluation_stage_index] = programs[m_fragment_stage_index];
10333                 programs[m_vertex_stage_index]                             = programs[m_fragment_stage_index];
10334         }
10335         else
10336         {
10337                 programs[m_fragment_stage_index]->build(0, fragmenty_shader_code, 0, 0, 0, 0, 0, 0, true);
10338                 programs[m_geometry_stage_index]->build(0, 0, geometry_shader_code, 0, 0, 0, 0, 0, true);
10339                 programs[m_tesselation_control_stage_index]->build(0, 0, 0, tesselation_control_shader_code, 0, 0, 0, 0, true);
10340                 programs[m_tesselation_evaluation_stage_index]->build(0, 0, 0, 0, tesselation_evaluation_shader_code, 0, 0, 0,
10341                                                                                                                           true);
10342                 programs[m_vertex_stage_index]->build(0, 0, 0, 0, 0, vertex_shader_code, 0, 0, true);
10343         }
10344
10345         /* Get subroutine indices */
10346         for (GLuint i = 0; i < n_subroutines; ++i)
10347         {
10348                 m_subroutine_indices[i].m_fragment_shader_stage =
10349                         programs[m_fragment_stage_index]->getSubroutineIndex(subroutine_names[i], GL_FRAGMENT_SHADER);
10350
10351                 m_subroutine_indices[i].m_geometry_shader_stage =
10352                         programs[m_geometry_stage_index]->getSubroutineIndex(subroutine_names[i], GL_GEOMETRY_SHADER);
10353
10354                 m_subroutine_indices[i].m_tesselation_control_shader_stage =
10355                         programs[m_tesselation_control_stage_index]->getSubroutineIndex(subroutine_names[i],
10356                                                                                                                                                         GL_TESS_CONTROL_SHADER);
10357
10358                 m_subroutine_indices[i].m_tesselation_evaluation_shader_stage =
10359                         programs[m_tesselation_evaluation_stage_index]->getSubroutineIndex(subroutine_names[i],
10360                                                                                                                                                            GL_TESS_EVALUATION_SHADER);
10361
10362                 m_subroutine_indices[i].m_vertex_shader_stage =
10363                         programs[m_vertex_stage_index]->getSubroutineIndex(subroutine_names[i], GL_VERTEX_SHADER);
10364         }
10365
10366         /* Get subroutine uniform locations */
10367         m_subroutine_uniform_locations.m_fragment_shader_stage =
10368                 programs[m_fragment_stage_index]->getSubroutineUniformLocation(subroutine_uniform_name, GL_FRAGMENT_SHADER);
10369
10370         m_subroutine_uniform_locations.m_geometry_shader_stage =
10371                 programs[m_geometry_stage_index]->getSubroutineUniformLocation(subroutine_uniform_name, GL_GEOMETRY_SHADER);
10372
10373         m_subroutine_uniform_locations.m_tesselation_control_shader_stage =
10374                 programs[m_tesselation_control_stage_index]->getSubroutineUniformLocation(subroutine_uniform_name,
10375                                                                                                                                                                   GL_TESS_CONTROL_SHADER);
10376
10377         m_subroutine_uniform_locations.m_tesselation_evaluation_shader_stage =
10378                 programs[m_tesselation_evaluation_stage_index]->getSubroutineUniformLocation(subroutine_uniform_name,
10379                                                                                                                                                                          GL_TESS_EVALUATION_SHADER);
10380
10381         m_subroutine_uniform_locations.m_vertex_shader_stage =
10382                 programs[m_vertex_stage_index]->getSubroutineUniformLocation(subroutine_uniform_name, GL_VERTEX_SHADER);
10383 }
10384
10385 /** Generate program pipeline for current context and attach separable programs
10386  *
10387  * @param out_pipeline_id Id of generated pipeline
10388  * @param programs        Collection of separable programs
10389  **/
10390 void FunctionalTest20_21::prepareProgramPipeline(glw::GLuint& out_pipeline_id, Utils::program** programs)
10391 {
10392         /* GL entry points */
10393         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
10394
10395         /* Generate */
10396         gl.genProgramPipelines(1, &out_pipeline_id);
10397         GLU_EXPECT_NO_ERROR(gl.getError(), "GenProgramPipelines");
10398
10399         /* Bind */
10400         gl.bindProgramPipeline(out_pipeline_id);
10401         GLU_EXPECT_NO_ERROR(gl.getError(), "BindProgramPipeline");
10402
10403         /* Set up programs */
10404         gl.useProgramStages(out_pipeline_id, GL_FRAGMENT_SHADER_BIT, programs[m_fragment_stage_index]->m_program_object_id);
10405         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgramStages");
10406
10407         gl.useProgramStages(out_pipeline_id, GL_GEOMETRY_SHADER_BIT, programs[m_geometry_stage_index]->m_program_object_id);
10408         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgramStages");
10409
10410         gl.useProgramStages(out_pipeline_id, GL_TESS_CONTROL_SHADER_BIT,
10411                                                 programs[m_tesselation_control_stage_index]->m_program_object_id);
10412         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgramStages");
10413
10414         gl.useProgramStages(out_pipeline_id, GL_TESS_EVALUATION_SHADER_BIT,
10415                                                 programs[m_tesselation_evaluation_stage_index]->m_program_object_id);
10416         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgramStages");
10417
10418         gl.useProgramStages(out_pipeline_id, GL_VERTEX_SHADER_BIT, programs[m_vertex_stage_index]->m_program_object_id);
10419         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgramStages");
10420 }
10421
10422 /** Test specific case
10423  *
10424  * @param bit_field An array of 5 bit fields used to set up subroutine uniforms, one element per context
10425  *
10426  * @return True if test pass, false otherwise
10427  **/
10428 bool FunctionalTest20_21::testCase(const glw::GLuint bit_field[5])
10429 {
10430         /* Storage for subroutine indices */
10431         subroutineUniformSet captured_subroutine_indices[m_n_shared_contexts + 1];
10432         subroutineUniformSet subroutine_indices[m_n_shared_contexts + 1];
10433
10434         /* Prepare subroutine_indices with bit fields */
10435         for (GLuint i = 0; i < m_n_shared_contexts + 1; ++i)
10436         {
10437                 subroutine_indices[i].set(bit_field[i], m_subroutine_indices);
10438         };
10439
10440         /* Update subroutine uniforms, each context gets different set */
10441         for (GLuint i = 0; i < m_n_shared_contexts; ++i)
10442         {
10443                 m_shared_contexts[i]->makeCurrent();
10444                 updateCurrentSubroutineSet(subroutine_indices[i]);
10445         }
10446
10447         m_context.getRenderContext().makeCurrent();
10448         updateCurrentSubroutineSet(subroutine_indices[m_n_shared_contexts]);
10449
10450         /* Capture subroutine uniforms */
10451         for (GLuint i = 0; i < m_n_shared_contexts; ++i)
10452         {
10453                 m_shared_contexts[i]->makeCurrent();
10454                 captureCurrentSubroutineSet(captured_subroutine_indices[i]);
10455         }
10456
10457         m_context.getRenderContext().makeCurrent();
10458         captureCurrentSubroutineSet(captured_subroutine_indices[m_n_shared_contexts]);
10459
10460         /* Verify that captured uniforms match expected values */
10461         for (GLuint i = 0; i < m_n_shared_contexts + 1; ++i)
10462         {
10463                 if (subroutine_indices[i] != captured_subroutine_indices[i])
10464                 {
10465                         m_context.getTestContext().getLog()
10466                                 << tcu::TestLog::Message << "Error."
10467                                 << " Context: " << i << " VS, expected: " << subroutine_indices[i].m_vertex_shader_stage
10468                                 << " captured: " << captured_subroutine_indices[i].m_vertex_shader_stage
10469                                 << " TCS, expected: " << subroutine_indices[i].m_tesselation_control_shader_stage
10470                                 << " captured: " << captured_subroutine_indices[i].m_tesselation_control_shader_stage
10471                                 << " TES, expected: " << subroutine_indices[i].m_tesselation_evaluation_shader_stage
10472                                 << " captured: " << captured_subroutine_indices[i].m_tesselation_evaluation_shader_stage
10473                                 << " GS, expected: " << subroutine_indices[i].m_geometry_shader_stage
10474                                 << " captured: " << captured_subroutine_indices[i].m_geometry_shader_stage
10475                                 << " FS, expected: " << subroutine_indices[i].m_fragment_shader_stage
10476                                 << " captured: " << captured_subroutine_indices[i].m_fragment_shader_stage << tcu::TestLog::EndMessage;
10477
10478                         return false;
10479                 }
10480         }
10481
10482         return true;
10483 }
10484
10485 /** Test a program or pipeline
10486  *
10487  * @param programs     An array of 5 programs\ pointers, as in preparePrograms
10488  * @param is_separable Selects if monolithic or separable programs should be used
10489  * @param test_cases   Collection of test cases
10490  * @param n_test_cases Number of test cases
10491  *
10492  * @return True if all cases pass, false otherwise
10493  **/
10494 bool FunctionalTest20_21::testProgram(Utils::program** programs, bool is_separable, const glw::GLuint test_cases[][5],
10495                                                                           glw::GLuint n_test_cases)
10496 {
10497         /* Set program/pipeline as current for all contexts */
10498         if (false == is_separable)
10499         {
10500                 programs[0]->use();
10501
10502                 for (GLuint i = 0; i < m_n_shared_contexts; ++i)
10503                 {
10504                         m_shared_contexts[i]->makeCurrent();
10505                         programs[0]->use();
10506                 }
10507         }
10508         else
10509         {
10510                 /* GL entry points */
10511                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
10512
10513                 /* Make sure that program pipeline will be used */
10514                 gl.useProgram(0);
10515                 GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");
10516
10517                 prepareProgramPipeline(m_program_pipelines[m_n_shared_contexts], programs);
10518
10519                 for (GLuint i = 0; i < m_n_shared_contexts; ++i)
10520                 {
10521                         m_shared_contexts[i]->makeCurrent();
10522
10523                         /* Make sure that program pipeline will be used */
10524                         gl.useProgram(0);
10525                         GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");
10526
10527                         prepareProgramPipeline(m_program_pipelines[i], programs);
10528                 }
10529         }
10530
10531         /* Execute test */
10532         bool result = true;
10533         for (GLuint i = 0; i < n_test_cases; ++i)
10534         {
10535                 if (false == testCase(test_cases[i]))
10536                 {
10537                         result = false;
10538                         break;
10539                 }
10540         }
10541
10542         return result;
10543 }
10544
10545 /** Set up subroutine uniforms for current program or pipeline
10546  *
10547  * @param set Set of subroutine indices
10548  **/
10549 void FunctionalTest20_21::updateCurrentSubroutineSet(const subroutineUniformSet& set)
10550 {
10551         /* GL entry points */
10552         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
10553
10554         /* Fragment */
10555         gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1 /* count */, &set.m_fragment_shader_stage);
10556         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
10557
10558         /* Geometry */
10559         gl.uniformSubroutinesuiv(GL_GEOMETRY_SHADER, 1 /* count */, &set.m_geometry_shader_stage);
10560         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
10561
10562         /* Tess ctrl */
10563         gl.uniformSubroutinesuiv(GL_TESS_CONTROL_SHADER, 1 /* count */, &set.m_tesselation_control_shader_stage);
10564         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
10565
10566         /* Tess eval */
10567         gl.uniformSubroutinesuiv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &set.m_tesselation_evaluation_shader_stage);
10568         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
10569
10570         /* Vertex */
10571         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 1 /* count */, &set.m_vertex_shader_stage);
10572         GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv");
10573 }
10574
10575 /** Constructor.
10576  *
10577  *  @param context Rendering context.
10578  *
10579  **/
10580 NegativeTest1::NegativeTest1(deqp::Context& context)
10581         : TestCase(context, "subroutine_errors", "Verifies all GL_INVALID_OPERATION, GL_INVALID_VALUE, GL_INVALID ENUM "
10582                                                                                          "errors related to subroutine usage are properly generated.")
10583         , m_has_test_passed(true)
10584         , m_po_active_subroutine_uniform_locations(0)
10585         , m_po_active_subroutine_uniforms(0)
10586         , m_po_active_subroutines(0)
10587         , m_po_subroutine_uniform_function_index(-1)
10588         , m_po_subroutine_uniform_function2_index(-1)
10589         , m_po_subroutine_test1_index(GL_INVALID_INDEX)
10590         , m_po_subroutine_test2_index(GL_INVALID_INDEX)
10591         , m_po_subroutine_test3_index(GL_INVALID_INDEX)
10592         , m_po_not_linked_id(0)
10593         , m_po_id(0)
10594         , m_vs_id(0)
10595 {
10596         /* Left blank intentionally */
10597 }
10598
10599 /** Deinitializes all GL objects that may have been created during
10600  *  test execution.
10601  **/
10602 void NegativeTest1::deinit()
10603 {
10604         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
10605
10606         if (m_po_id != 0)
10607         {
10608                 gl.deleteProgram(m_po_id);
10609
10610                 m_po_id = 0;
10611         }
10612
10613         if (m_po_not_linked_id != 0)
10614         {
10615                 gl.deleteProgram(m_po_not_linked_id);
10616
10617                 m_po_not_linked_id = 0;
10618         }
10619
10620         if (m_vs_id != 0)
10621         {
10622                 gl.deleteShader(m_vs_id);
10623
10624                 m_vs_id = 0;
10625         }
10626 }
10627
10628 /** Initializes all GL objects required to run the test.  */
10629 void NegativeTest1::initTest()
10630 {
10631         glw::GLint                        compile_status = GL_FALSE;
10632         const glw::Functions& gl                         = m_context.getRenderContext().getFunctions();
10633
10634         /* Create program objects */
10635         m_po_not_linked_id = gl.createProgram();
10636         m_po_id                    = gl.createProgram();
10637         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call(s) failed.");
10638
10639         /* Create vertex shader object */
10640         m_vs_id = gl.createShader(GL_VERTEX_SHADER);
10641         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
10642
10643         /* Set up vertex shader */
10644         const char* vs_body = "#version 400\n"
10645                                                   "\n"
10646                                                   "#extension GL_ARB_shader_subroutine : require\n"
10647                                                   "\n"
10648                                                   "subroutine void subroutineType (out ivec2 arg);\n"
10649                                                   "subroutine void subroutineType2(out ivec4 arg);\n"
10650                                                   "\n"
10651                                                   "subroutine(subroutineType) void test1(out ivec2 arg)\n"
10652                                                   "{\n"
10653                                                   "    arg = ivec2(1, 2);\n"
10654                                                   "}\n"
10655                                                   "subroutine(subroutineType) void test2(out ivec2 arg)\n"
10656                                                   "{\n"
10657                                                   "    arg = ivec2(3,4);\n"
10658                                                   "}\n"
10659                                                   "subroutine(subroutineType2) void test3(out ivec4 arg)\n"
10660                                                   "{\n"
10661                                                   "    arg = ivec4(1, 2, 3, 4);\n"
10662                                                   "}\n"
10663                                                   "\n"
10664                                                   "subroutine uniform subroutineType  function;\n"
10665                                                   "subroutine uniform subroutineType2 function2;\n"
10666                                                   "\n"
10667                                                   "void main()\n"
10668                                                   "{\n"
10669                                                   "    ivec2 test;\n"
10670                                                   "    ivec4 test2;\n"
10671                                                   "\n"
10672                                                   "    function(test);\n"
10673                                                   "\n"
10674                                                   "    if (test.x > 2)\n"
10675                                                   "    {\n"
10676                                                   "        gl_Position = vec4(1);\n"
10677                                                   "    }\n"
10678                                                   "    else\n"
10679                                                   "    {\n"
10680                                                   "        function2(test2);\n"
10681                                                   "\n"
10682                                                   "        gl_Position = vec4(float(test2.x) );\n"
10683                                                   "    }\n"
10684                                                   "}\n";
10685
10686         gl.shaderSource(m_vs_id, 1 /* count */, &vs_body, DE_NULL /* length */);
10687         GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed");
10688
10689         gl.compileShader(m_vs_id);
10690         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed");
10691
10692         gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status);
10693         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed");
10694
10695         if (compile_status == GL_FALSE)
10696         {
10697                 TCU_FAIL("Shader compilation failed");
10698         }
10699
10700         /* Set up & link the test program object */
10701         glw::GLint link_status = GL_FALSE;
10702
10703         gl.attachShader(m_po_id, m_vs_id);
10704         GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed.");
10705
10706         gl.linkProgram(m_po_id);
10707         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed.");
10708
10709         gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status);
10710         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
10711
10712         if (link_status == GL_FALSE)
10713         {
10714                 TCU_FAIL("Program linking failed");
10715         }
10716
10717         /* Query test program object's properties */
10718         gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS,
10719                                                  &m_po_active_subroutine_uniform_locations);
10720         gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &m_po_active_subroutine_uniforms);
10721         gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &m_po_active_subroutines);
10722         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call(s) failed.");
10723
10724         if (m_po_active_subroutine_uniform_locations != 2)
10725         {
10726                 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS value returned");
10727         }
10728
10729         m_po_subroutine_test1_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test1");
10730         m_po_subroutine_test2_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test2");
10731         m_po_subroutine_test3_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test3");
10732         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed.");
10733
10734         if (m_po_subroutine_test1_index == GL_INVALID_INDEX || m_po_subroutine_test2_index == GL_INVALID_INDEX ||
10735                 m_po_subroutine_test3_index == GL_INVALID_INDEX)
10736         {
10737                 TCU_FAIL("Invalid subroutine index returned");
10738         }
10739
10740         m_po_subroutine_uniform_function_index  = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function");
10741         m_po_subroutine_uniform_function2_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function2");
10742         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed.");
10743
10744         if (m_po_subroutine_uniform_function_index == -1 || m_po_subroutine_uniform_function2_index == -1)
10745         {
10746                 TCU_FAIL("Invalid subroutine uniform index returned");
10747         }
10748 }
10749
10750 /** Executes test iteration.
10751  *
10752  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
10753  */
10754 tcu::TestNode::IterateResult NegativeTest1::iterate()
10755 {
10756         glw::GLenum                       error_code = GL_NO_ERROR;
10757         const glw::Functions& gl                 = m_context.getRenderContext().getFunctions();
10758
10759         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
10760         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
10761         {
10762                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
10763         }
10764
10765         /* Initialize GL objects required to run the test */
10766         initTest();
10767
10768         /* The error INVALID_OPERATION is generated by GetSubroutineUniformLocation
10769          * if the program object identified by <program> has not been successfully
10770          * linked.
10771          */
10772         gl.getSubroutineUniformLocation(m_po_not_linked_id, GL_FRAGMENT_SHADER, "subroutine_uniform_name");
10773
10774         error_code = gl.getError();
10775
10776         if (error_code != GL_INVALID_OPERATION)
10777         {
10778                 m_testCtx.getLog() << tcu::TestLog::Message
10779                                                    << "glGetSubroutineUniformLocation() does not generate GL_INVALID_OPERATION "
10780                                                           "error code when called for a non-linked program object."
10781                                                    << tcu::TestLog::EndMessage;
10782
10783                 m_has_test_passed = false;
10784         }
10785
10786         /* The error INVALID_VALUE is generated by GetActiveSubroutineUniformiv or
10787          * GetActiveSubroutineUniformName if <index> is greater than or equal to the
10788          * value of ACTIVE_SUBROUTINE_UNIFORMS for the shader stage.
10789          */
10790         glw::GLint temp_length = 0;
10791         glw::GLint temp_values = 0;
10792
10793         gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms,
10794                                                                         GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values);
10795         error_code = gl.getError();
10796
10797         if (error_code == GL_INVALID_VALUE)
10798         {
10799                 gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1,
10800                                                                                 GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values);
10801
10802                 error_code = gl.getError();
10803         }
10804
10805         if (error_code != GL_INVALID_VALUE)
10806         {
10807                 m_testCtx.getLog() << tcu::TestLog::Message
10808                                                    << "glGetActiveSubroutineUniformiv() does not generate GL_INVALID_VALUE "
10809                                                           "when passed <index> argument that is greater than or equal to "
10810                                                           "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS."
10811                                                    << tcu::TestLog::EndMessage;
10812
10813                 m_has_test_passed = false;
10814         }
10815
10816         gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms, 0, /* bufsize */
10817                                                                           &temp_length, DE_NULL);                                                                                /* name */
10818         error_code = gl.getError();
10819
10820         if (error_code == GL_INVALID_VALUE)
10821         {
10822                 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1,
10823                                                                                   0,                                      /* bufsize */
10824                                                                                   &temp_length, DE_NULL); /* name */
10825
10826                 error_code = gl.getError();
10827         }
10828
10829         if (error_code != GL_INVALID_VALUE)
10830         {
10831                 m_testCtx.getLog() << tcu::TestLog::Message
10832                                                    << "glGetActiveSubroutineUniformName() does not generate GL_INVALID_VALUE "
10833                                                           "when passed <index> argument that is greater than or equal to "
10834                                                           "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS."
10835                                                    << tcu::TestLog::EndMessage;
10836
10837                 m_has_test_passed = false;
10838         }
10839
10840         /* The error INVALID_VALUE is generated by GetActiveSubroutineName if <index>
10841          * is greater than or equal to the value of ACTIVE_SUBROUTINES for the shader
10842          * stage.
10843          */
10844         gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines, 0, /* bufsize */
10845                                                            &temp_length, DE_NULL);                                                                /* name */
10846         error_code = gl.getError();
10847
10848         if (error_code == GL_INVALID_VALUE)
10849         {
10850                 gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines + 1, 0, /* bufsize */
10851                                                                    &temp_length, DE_NULL);                                                                        /* name */
10852
10853                 error_code = gl.getError();
10854         }
10855
10856         if (error_code != GL_INVALID_VALUE)
10857         {
10858                 m_testCtx.getLog() << tcu::TestLog::Message << "glGetActiveSubroutineName() does not generate GL_INVALID_VALUE "
10859                                                                                                            "when passed <index> argument that is greater than or equal to "
10860                                                                                                            "the value of GL_ACTIVE_SUBROUTINES."
10861                                                    << tcu::TestLog::EndMessage;
10862
10863                 m_has_test_passed = false;
10864         }
10865
10866         /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if <count>
10867          * is not equal to the value of ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the
10868          * shader stage <shadertype>.
10869          */
10870         glw::GLuint index = 0;
10871
10872         gl.useProgram(m_po_id);
10873         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
10874
10875         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations - 1, &index);
10876         error_code = gl.getError();
10877
10878         if (error_code == GL_INVALID_VALUE)
10879         {
10880                 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &index);
10881
10882                 error_code = gl.getError();
10883         }
10884
10885         if (error_code != GL_INVALID_VALUE)
10886         {
10887                 m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesiv() does not generate GL_INVALID_VALUE "
10888                                                                                                            "when passed <count> argument that is not equal to the value of "
10889                                                                                                            "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS."
10890                                                    << tcu::TestLog::EndMessage;
10891
10892                 m_has_test_passed = false;
10893         }
10894
10895         /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if any value
10896          * in <indices> is greater than or equal to the value of ACTIVE_SUBROUTINES
10897          * for the shader stage.
10898          */
10899         glw::GLuint invalid_subroutine_indices[4] = { (GLuint)m_po_active_subroutines, (GLuint)m_po_active_subroutines,
10900                                                                                                   (GLuint)m_po_active_subroutines + 1,
10901                                                                                                   (GLuint)m_po_active_subroutines + 1 };
10902
10903         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, /* count */
10904                                                          invalid_subroutine_indices + 0);
10905         error_code = gl.getError();
10906
10907         if (error_code == GL_INVALID_VALUE)
10908         {
10909                 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations,
10910                                                                  invalid_subroutine_indices + 2);
10911
10912                 error_code = gl.getError();
10913         }
10914
10915         if (error_code != GL_INVALID_VALUE)
10916         {
10917                 m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesuiv() does not generate GL_INVALID_VALUE "
10918                                                                                                            "when the value passed via <indices> argument is greater than "
10919                                                                                                            "or equal to the value of GL_ACTIVE_SUBROUTINES."
10920                                                    << tcu::TestLog::EndMessage;
10921
10922                 m_has_test_passed = false;
10923         }
10924
10925         /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv() if any
10926          * subroutine index in <indices> identifies a subroutine not associated with
10927          * the type of the subroutine uniform variable assigned to the corresponding
10928          * location.
10929          */
10930         glw::GLuint invalid_subroutine_indices2[2] = { m_po_subroutine_test1_index, m_po_subroutine_test1_index };
10931
10932         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, invalid_subroutine_indices2);
10933         error_code = gl.getError();
10934
10935         if (error_code != GL_INVALID_OPERATION)
10936         {
10937                 m_testCtx.getLog() << tcu::TestLog::Message
10938                                                    << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION "
10939                                                           "when the subroutine index passed via <indices> argument identifies"
10940                                                           "a subroutine not associated with the type of the subroutine uniform "
10941                                                           "assigned to the corresponding location."
10942                                                    << tcu::TestLog::EndMessage;
10943
10944                 m_has_test_passed = false;
10945         }
10946
10947         /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv if no
10948          * program is active.
10949          */
10950         glw::GLuint valid_subroutine_locations[2] = { 0 };
10951
10952         valid_subroutine_locations[m_po_subroutine_uniform_function_index]  = m_po_subroutine_test1_index;
10953         valid_subroutine_locations[m_po_subroutine_uniform_function2_index] = m_po_subroutine_test3_index;
10954
10955         gl.useProgram(0);
10956         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
10957
10958         gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, valid_subroutine_locations);
10959         error_code = gl.getError();
10960
10961         if (error_code != GL_INVALID_OPERATION)
10962         {
10963                 m_testCtx.getLog() << tcu::TestLog::Message
10964                                                    << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION "
10965                                                           "when called without an active program object."
10966                                                    << tcu::TestLog::EndMessage;
10967
10968                 m_has_test_passed = false;
10969         }
10970
10971         /* The error INVALID_VALUE is generated by GetUniformSubroutineuiv if
10972          * <location> is greater than or equal to the value of
10973          * ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the shader stage.
10974          */
10975         glw::GLuint temp_value = 0;
10976
10977         gl.useProgram(m_po_id);
10978         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
10979
10980         gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, &temp_value);
10981         error_code = gl.getError();
10982
10983         if (error_code == GL_INVALID_VALUE)
10984         {
10985                 gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &temp_value);
10986                 error_code = gl.getError();
10987         }
10988
10989         if (error_code != GL_INVALID_VALUE)
10990         {
10991                 m_testCtx.getLog() << tcu::TestLog::Message
10992                                                    << "glGetUniformSubroutineuiv() does not generate GL_INVALID_VALUE "
10993                                                           "when called for location that is greater than or equal to the value "
10994                                                           "of GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS."
10995                                                    << tcu::TestLog::EndMessage;
10996
10997                 m_has_test_passed = false;
10998         }
10999
11000         /* The error INVALID_OPERATION is generated by GetUniformSubroutineuiv if no
11001          * program is active for the shader stage identified by <shadertype>.
11002          */
11003         const glw::GLenum undefined_shader_stages[] = { GL_FRAGMENT_SHADER, GL_GEOMETRY_SHADER, GL_TESS_CONTROL_SHADER,
11004                                                                                                         GL_TESS_EVALUATION_SHADER };
11005         const unsigned int n_undefined_shader_stages = sizeof(undefined_shader_stages) / sizeof(undefined_shader_stages[0]);
11006
11007         for (unsigned int n_undefined_shader_stage = 0; n_undefined_shader_stage < n_undefined_shader_stages;
11008                  ++n_undefined_shader_stage)
11009         {
11010                 glw::GLenum shader_stage = undefined_shader_stages[n_undefined_shader_stage];
11011
11012                 gl.getUniformSubroutineuiv(shader_stage, 0, /* location */
11013                                                                    &temp_value);
11014                 error_code = gl.getError();
11015
11016                 if (error_code != GL_INVALID_OPERATION)
11017                 {
11018                         m_testCtx.getLog() << tcu::TestLog::Message
11019                                                            << "glGetUniformSubroutineuiv() does not generate GL_INVALID_OPERATION "
11020                                                                   "when called for a shader stage that is not defined for active "
11021                                                                   "program object."
11022                                                            << tcu::TestLog::EndMessage;
11023
11024                         m_has_test_passed = false;
11025                 }
11026         } /* for (all undefined shader stages) */
11027
11028         /* All done */
11029         if (m_has_test_passed)
11030         {
11031                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
11032         }
11033         else
11034         {
11035                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
11036         }
11037
11038         return STOP;
11039 }
11040
11041 /** Constructor
11042  *
11043  *  @param context Rendering context.
11044  *
11045  **/
11046 NegativeTest2::NegativeTest2(deqp::Context& context)
11047         : TestCase(context, "subroutine_uniform_scope", "Verifies subroutine uniforms declared in shader stage A"
11048                                                                                                         "cannot be accessed from a different stage.")
11049         , m_fs_id(0)
11050         , m_gs_id(0)
11051         , m_has_test_passed(true)
11052         , m_po_id(0)
11053         , m_tc_id(0)
11054         , m_te_id(0)
11055         , m_vs_id(0)
11056 {
11057         /* Left blank intentionally */
11058 }
11059
11060 /** Deinitializes all GL objects that may have been created during test execution */
11061 void NegativeTest2::deinit()
11062 {
11063         deinitGLObjects();
11064 }
11065
11066 /** Deinitializes all GL objects that may have been created during test execution */
11067 void NegativeTest2::deinitGLObjects()
11068 {
11069         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11070
11071         if (m_fs_id != 0)
11072         {
11073                 gl.deleteShader(m_fs_id);
11074
11075                 m_fs_id = 0;
11076         }
11077
11078         if (m_gs_id != 0)
11079         {
11080                 gl.deleteShader(m_gs_id);
11081
11082                 m_gs_id = 0;
11083         }
11084
11085         if (m_tc_id != 0)
11086         {
11087                 gl.deleteShader(m_tc_id);
11088
11089                 m_tc_id = 0;
11090         }
11091
11092         if (m_te_id != 0)
11093         {
11094                 gl.deleteShader(m_te_id);
11095
11096                 m_te_id = 0;
11097         }
11098
11099         if (m_vs_id != 0)
11100         {
11101                 gl.deleteShader(m_vs_id);
11102
11103                 m_vs_id = 0;
11104         }
11105
11106         if (m_po_id != 0)
11107         {
11108                 gl.deleteProgram(m_po_id);
11109
11110                 m_po_id = 0;
11111         }
11112 }
11113
11114 /** Builds an offending program object and tries to link it. We're either expecting
11115  *  a compile-time or link-time error here.
11116  *
11117  *  If the program object builds successfully, the test has failed.
11118  *
11119  *  @param referencing_stage Shader stage which defines a subroutine uniform that
11120  *                           should be called from fragment/geometry/tess control/
11121  *                           tess evaluation/vertex shader stages.
11122  *
11123  **/
11124 void NegativeTest2::executeTestCase(const Utils::_shader_stage& referencing_stage)
11125 {
11126         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11127
11128         const std::string fs_body = getFragmentShaderBody(referencing_stage);
11129         const std::string gs_body = getGeometryShaderBody(referencing_stage);
11130         const std::string tc_body = getTessellationControlShaderBody(referencing_stage);
11131         const std::string te_body = getTessellationEvaluationShaderBody(referencing_stage);
11132         const std::string vs_body = getVertexShaderBody(referencing_stage);
11133
11134         if (Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, NULL, /* xfb_varyings */
11135                                                         0,                                                                                                         /* n_xfb_varyings */
11136                                                         &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id))
11137         {
11138                 /* Test program should not have built correctly ! */
11139                 m_testCtx.getLog() << tcu::TestLog::Message << "In the following program, one of the stages references "
11140                                                                                                            "a subroutine that is defined in another stage. This "
11141                                                                                                            "is forbidden by the specification.\n"
11142                                                                                                            "\n"
11143                                                                                                            "Vertex shader:\n\n"
11144                                                    << vs_body.c_str() << "\n\nTessellation control shader:\n\n"
11145                                                    << tc_body.c_str() << "\n\nTessellation evaluation shader:\n\n"
11146                                                    << te_body.c_str() << "\n\nGeometry shader:\n\n"
11147                                                    << gs_body.c_str() << "\n\nFragment shader:\n\n"
11148                                                    << fs_body.c_str() << tcu::TestLog::EndMessage;
11149
11150                 m_has_test_passed = false;
11151         } /* if (test program was built successfully) */
11152
11153         /* Release the shaders & the program object that buildProgram() created */
11154         deinitGLObjects();
11155 }
11156
11157 /** Retrieves an offending fragment shader body.
11158  *
11159  *  @param referencing_stage Shader stage which defines the subroutine uniform that
11160  *                           will be called from fragment shader.
11161  *
11162  *  @return Requested string.
11163  **/
11164 std::string NegativeTest2::getFragmentShaderBody(const Utils::_shader_stage& referencing_stage) const
11165 {
11166         std::stringstream result;
11167
11168         /* Form the pre-amble */
11169         result << "#version 400\n"
11170                           "\n"
11171                           "#extension GL_ARB_shader_subroutine : require\n"
11172                           "\n"
11173                           "subroutine void testSubroutineType(out vec4 test_argument);\n"
11174                           "\n"
11175                           /* Define a subroutine */
11176                           "subroutine(testSubroutineType) void fs_subroutine(out vec4 test_argument)\n"
11177                           "{\n"
11178                           "    test_argument = vec4(1, 0, 0, 0);\n"
11179                           "}\n"
11180                           "\n"
11181                           /* Define output variables */
11182                           "out vec4 result;\n"
11183                           "\n"
11184                           /* Define uniforms */
11185                           "subroutine uniform testSubroutineType test_fs_subroutine;\n"
11186                           "\n"
11187                           /* Define main() */
11188                           "void main()\n"
11189                           "{\n"
11190                           "    "
11191                    << getSubroutineUniformName(referencing_stage) << "(result);\n"
11192                                                                                                                          "}\n";
11193
11194         return result.str();
11195 }
11196
11197 /** Retrieves an offending geometry shader body.
11198  *
11199  *  @param referencing_stage Shader stage which defines the subroutine uniform that
11200  *                           will be called from geometry shader.
11201  *
11202  *  @return Requested string.
11203  **/
11204 std::string NegativeTest2::getGeometryShaderBody(const Utils::_shader_stage& referencing_stage) const
11205 {
11206         std::stringstream result;
11207
11208         /* Form the pre-amble */
11209         result << "#version 400\n"
11210                           "\n"
11211                           "#extension GL_ARB_shader_subroutine : require\n"
11212                           "\n"
11213                           "subroutine void testSubroutineType(out vec4 test_argument);\n"
11214                           "\n"
11215                           "layout(points)                   in;\n"
11216                           "layout(points, max_vertices = 1) out;\n"
11217                           "\n"
11218                           /* Define a subroutine */
11219                           "subroutine(testSubroutineType) void gs_subroutine(out vec4 test_argument)\n"
11220                           "{\n"
11221                           "    test_argument = vec4(0, 1, 1, 1);\n"
11222                           "}\n"
11223                           "\n"
11224                           /* Define output variables */
11225                           "out vec4 result;\n"
11226                           "\n"
11227                           /* Define uniforms */
11228                           "subroutine uniform testSubroutineType test_gs_subroutine;\n"
11229                           "\n"
11230                           /* Define main() */
11231                           "void main()\n"
11232                           "{\n"
11233                           "    "
11234                    << getSubroutineUniformName(referencing_stage) << "(result);\n"
11235                                                                                                                          "}\n";
11236
11237         return result.str();
11238 }
11239
11240 /** Retrieves name of the subroutine uniform that is defined in user-specified
11241  *  shader stage.
11242  *
11243  *  @param stage Shader stage to retrieve the subroutine uniform name for.
11244  *
11245  *  @return As per description.
11246  **/
11247 std::string NegativeTest2::getSubroutineUniformName(const Utils::_shader_stage& stage) const
11248 {
11249         std::string result = "?";
11250
11251         switch (stage)
11252         {
11253         case Utils::SHADER_STAGE_FRAGMENT:
11254         {
11255                 result = "test_fs_subroutine";
11256
11257                 break;
11258         }
11259
11260         case Utils::SHADER_STAGE_GEOMETRY:
11261         {
11262                 result = "test_gs_subroutine";
11263
11264                 break;
11265         }
11266
11267         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
11268         {
11269                 result = "test_tc_subroutine";
11270
11271                 break;
11272         }
11273
11274         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
11275         {
11276                 result = "test_te_subroutine";
11277
11278                 break;
11279         }
11280
11281         case Utils::SHADER_STAGE_VERTEX:
11282         {
11283                 result = "test_vs_subroutine";
11284
11285                 break;
11286         }
11287
11288         default:
11289         {
11290                 TCU_FAIL("Unrecognized shader stage requested");
11291         }
11292         } /* switch (stage) */
11293
11294         return result;
11295 }
11296
11297 /** Retrieves an offending tessellation control shader body.
11298  *
11299  *  @param referencing_stage Shader stage which defines the subroutine uniform that
11300  *                           will be called from tessellation control shader.
11301  *
11302  *  @return Requested string.
11303  **/
11304 std::string NegativeTest2::getTessellationControlShaderBody(const Utils::_shader_stage& referencing_stage) const
11305 {
11306         std::stringstream result;
11307
11308         /* Form the pre-amble */
11309         result << "#version 400\n"
11310                           "\n"
11311                           "#extension GL_ARB_shader_subroutine : require\n"
11312                           "\n"
11313                           "layout(vertices = 4) out;\n"
11314                           "\n"
11315                           "subroutine void testSubroutineType(out vec4 test_argument);\n"
11316                           "\n"
11317                           /* Define a subroutine */
11318                           "subroutine(testSubroutineType) void tc_subroutine(out vec4 test_argument)\n"
11319                           "{\n"
11320                           "    test_argument = vec4(0, 0, 1, 0);\n"
11321                           "}\n"
11322                           "\n"
11323                           /* Define uniforms */
11324                           "subroutine uniform testSubroutineType test_tc_subroutine;\n"
11325                           "\n"
11326                           /* Define main() */
11327                           "void main()\n"
11328                           "{\n"
11329                           "    "
11330                    << getSubroutineUniformName(referencing_stage) << "(gl_out[gl_InvocationID].gl_Position);\n"
11331                                                                                                                          "}\n";
11332
11333         return result.str();
11334 }
11335
11336 /** Retrieves an offending tessellation evaluation shader body.
11337  *
11338  *  @param referencing_stage Shader stage which defines the subroutine uniform that
11339  *                           will be called from tessellation evaluation shader.
11340  *
11341  *  @return Requested string.
11342  **/
11343 std::string NegativeTest2::getTessellationEvaluationShaderBody(const Utils::_shader_stage& referencing_stage) const
11344 {
11345         std::stringstream result;
11346
11347         /* Form the pre-amble */
11348         result << "#version 400\n"
11349                           "\n"
11350                           "#extension GL_ARB_shader_subroutine : require\n"
11351                           "\n"
11352                           "layout(quads) in;\n"
11353                           "\n"
11354                           "subroutine void testSubroutineType(out vec4 test_argument);\n"
11355                           "\n"
11356                           /* Define a subroutine */
11357                           "subroutine(testSubroutineType) void te_subroutine(out vec4 test_argument)\n"
11358                           "{\n"
11359                           "    test_argument = vec4(1, 1, 1, 1);\n"
11360                           "}\n"
11361                           "\n"
11362                           /* Define uniforms */
11363                           "subroutine uniform testSubroutineType test_te_subroutine;\n"
11364                           "\n"
11365                           /* Define main() */
11366                           "void main()\n"
11367                           "{\n"
11368                           "    "
11369                    << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n"
11370                                                                                                                          "}\n";
11371
11372         return result.str();
11373 }
11374
11375 /** Retrieves an offending vertex shader body.
11376  *
11377  *  @param referencing_stage Shader stage which defines the subroutine uniform that
11378  *                           will be called from vertex shader.
11379  *
11380  *  @return Requested string.
11381  **/
11382 std::string NegativeTest2::getVertexShaderBody(const Utils::_shader_stage& referencing_stage) const
11383 {
11384         std::stringstream result;
11385
11386         /* Form the pre-amble */
11387         result << "#version 400\n"
11388                           "\n"
11389                           "#extension GL_ARB_shader_subroutine : require\n"
11390                           "\n"
11391                           "subroutine void testSubroutineType(out vec4 test_argument);\n"
11392                           "\n"
11393                           /* Define a subroutine */
11394                           "subroutine(testSubroutineType) void vs_subroutine(out vec4 test_argument)\n"
11395                           "{\n"
11396                           "    test_argument = vec4(0, 1, 0, 0);\n"
11397                           "}\n"
11398                           "\n"
11399                           /* Define uniforms */
11400                           "subroutine uniform testSubroutineType test_vs_subroutine;\n"
11401                           "\n"
11402                           /* Define main() */
11403                           "void main()\n"
11404                           "{\n"
11405                           "    "
11406                    << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n"
11407                                                                                                                          "}\n";
11408
11409         return result.str();
11410 }
11411
11412 /** Executes test iteration.
11413  *
11414  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
11415  */
11416 tcu::TestNode::IterateResult NegativeTest2::iterate()
11417 {
11418         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
11419         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
11420         {
11421                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
11422         }
11423
11424         /* Iterate over all shader stages and execute the checks */
11425         for (int referencing_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
11426                  referencing_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++referencing_stage)
11427         {
11428                 executeTestCase(static_cast<Utils::_shader_stage>(referencing_stage));
11429         } /* for (all test cases) */
11430
11431         /* All done */
11432         if (m_has_test_passed)
11433         {
11434                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
11435         }
11436         else
11437         {
11438                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
11439         }
11440
11441         return STOP;
11442 }
11443
11444 /** Constructor.
11445  *
11446  *  @param context Rendering context.
11447  *
11448  **/
11449 NegativeTest3::NegativeTest3(deqp::Context& context)
11450         : TestCase(context, "missing_subroutine_keyword", "Verifies that subroutine keyword is necessary when declaring a "
11451                                                                                                           "subroutine uniforn and a compilation error occurs without it.")
11452         , m_has_test_passed(true)
11453         , m_so_id(0)
11454 {
11455         /* Left blank intentionally */
11456 }
11457
11458 /** Deinitializes all GL objects that may have been created during test execution */
11459 void NegativeTest3::deinit()
11460 {
11461         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11462
11463         if (m_so_id != 0)
11464         {
11465                 gl.deleteShader(m_so_id);
11466
11467                 m_so_id = 0;
11468         }
11469 }
11470
11471 /** Verifies that broken shader (for user-specified shader stage) does not compile.
11472  *
11473  *  @param shader_stage Shader stage to use for the test.
11474  **/
11475 void NegativeTest3::executeTest(const Utils::_shader_stage& shader_stage)
11476 {
11477         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11478
11479         /* Generate a new shader object */
11480         m_so_id = gl.createShader(Utils::getGLenumForShaderStage(shader_stage));
11481         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed.");
11482
11483         /* Assign body to the shader */
11484         std::string body;
11485         const char* body_raw_ptr = DE_NULL;
11486
11487         switch (shader_stage)
11488         {
11489         case Utils::SHADER_STAGE_VERTEX:
11490                 body = getVertexShaderBody();
11491                 break;
11492         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
11493                 body = getTessellationControlShaderBody();
11494                 break;
11495         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
11496                 body = getTessellationEvaluationShaderBody();
11497                 break;
11498         case Utils::SHADER_STAGE_GEOMETRY:
11499                 body = getGeometryShaderBody();
11500                 break;
11501         case Utils::SHADER_STAGE_FRAGMENT:
11502                 body = getFragmentShaderBody();
11503                 break;
11504
11505         default:
11506         {
11507                 TCU_FAIL("Unrecognized shader stage requested");
11508         }
11509         } /* switch (shader_stage) */
11510
11511         body_raw_ptr = body.c_str();
11512
11513         gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL /* length */);
11514         GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
11515
11516         /* Try to compile the shader */
11517         glw::GLint compile_status = 0;
11518
11519         gl.compileShader(m_so_id);
11520         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
11521
11522         gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status);
11523         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
11524
11525         if (compile_status == GL_TRUE)
11526         {
11527                 m_testCtx.getLog() << tcu::TestLog::Message << "The following shader was expected to fail to compile but was "
11528                                                                                                            "accepted by the compiler:\n"
11529                                                                                                            "\n"
11530                                                    << body.c_str() << tcu::TestLog::EndMessage;
11531
11532                 m_has_test_passed = false;
11533         }
11534
11535         /* Good to release the shader at this point */
11536         gl.deleteShader(m_so_id);
11537         GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed.");
11538 }
11539
11540 /** Retrieves body of a broken fragment shader.
11541  *
11542  *  @return Requested string.
11543  **/
11544 std::string NegativeTest3::getFragmentShaderBody() const
11545 {
11546         return "#version 400\n"
11547                    "\n"
11548                    "#extension GL_ARB_shader_subroutine : require\n"
11549                    "\n"
11550                    "subroutine void testSubroutineType(inout vec4 test);\n"
11551                    "\n"
11552                    "void testSubroutine1(inout vec4 test)\n"
11553                    "{\n"
11554                    "    test += vec4(3, 4, 5, 6);\n"
11555                    "}\n"
11556                    "\n"
11557                    "uniform testSubroutineType subroutineFunction;\n"
11558                    "out     vec4               result;\n"
11559                    "\n"
11560                    "void main()\n"
11561                    "{\n"
11562                    "    vec4 test = vec4(2, 3, 4, 5);\n"
11563                    "\n"
11564                    "    subroutineFunction(test);\n"
11565                    "\n"
11566                    "    result = test;\n"
11567                    "}\n";
11568 }
11569
11570 /** Retrieves body of a broken geometry shader.
11571  *
11572  *  @return Requested string.
11573  **/
11574 std::string NegativeTest3::getGeometryShaderBody() const
11575 {
11576         return "#version 400\n"
11577                    "\n"
11578                    "#extension GL_ARB_shader_subroutine : require\n"
11579                    "\n"
11580                    "layout(points)                   in;\n"
11581                    "layout(points, max_vertices = 1) out;\n"
11582                    "\n"
11583                    "subroutine void testSubroutineType(inout vec4 test);\n"
11584                    "\n"
11585                    "void testSubroutine1(inout vec4 test)\n"
11586                    "{\n"
11587                    "    test += vec4(3, 4, 5, 6);\n"
11588                    "}\n"
11589                    "\n"
11590                    "uniform testSubroutineType subroutineFunction;\n"
11591                    "\n"
11592                    "void main()\n"
11593                    "{\n"
11594                    "    vec4 test = vec4(2, 3, 4, 5);\n"
11595                    "\n"
11596                    "    subroutineFunction(test);\n"
11597                    "\n"
11598                    "    gl_Position = test;\n"
11599                    "    EmitVertex();\n"
11600                    "}\n";
11601 }
11602
11603 /** Retrieves body of a broken tessellation control shader.
11604  *
11605  *  @return Requested string.
11606  **/
11607 std::string NegativeTest3::getTessellationControlShaderBody() const
11608 {
11609         return "#version 400\n"
11610                    "\n"
11611                    "#extension GL_ARB_shader_subroutine : require\n"
11612                    "\n"
11613                    "layout(vertices=4) out;\n"
11614                    "\n"
11615                    "subroutine void testSubroutineType(inout vec4 test);\n"
11616                    "\n"
11617                    "void testSubroutine1(inout vec4 test)\n"
11618                    "{\n"
11619                    "    test += vec4(1, 2, 3, 4);\n"
11620                    "}\n"
11621                    "\n"
11622                    "uniform testSubroutineType subroutineFunction;\n"
11623                    "\n"
11624                    "void main()\n"
11625                    "{\n"
11626                    "    vec4 test = vec4(0, 1, 2, 3);\n"
11627                    "\n"
11628                    "    subroutineFunction(test);\n"
11629                    "\n"
11630                    "    gl_out[gl_InvocationID].gl_Position = test;\n"
11631                    "}\n";
11632 }
11633
11634 /** Retrieves body of a broken tessellation evaluation shader.
11635  *
11636  *  @return Requested string.
11637  **/
11638 std::string NegativeTest3::getTessellationEvaluationShaderBody() const
11639 {
11640         return "#version 400\n"
11641                    "\n"
11642                    "#extension GL_ARB_shader_subroutine : require\n"
11643                    "\n"
11644                    "layout(quads) in;\n"
11645                    "\n"
11646                    "subroutine void testSubroutineType(inout vec4 test);\n"
11647                    "\n"
11648                    "void testSubroutine1(inout vec4 test)\n"
11649                    "{\n"
11650                    "    test += vec4(2, 3, 4, 5);\n"
11651                    "}\n"
11652                    "\n"
11653                    "uniform testSubroutineType subroutineFunction;\n"
11654                    "\n"
11655                    "void main()\n"
11656                    "{\n"
11657                    "    vec4 test = vec4(1, 2, 3, 4);\n"
11658                    "\n"
11659                    "    subroutineFunction(test);\n"
11660                    "\n"
11661                    "    gl_Position = test;\n"
11662                    "}\n";
11663 }
11664
11665 /** Retrieves body of a broken vertex shader.
11666  *
11667  *  @return Requested string.
11668  **/
11669 std::string NegativeTest3::getVertexShaderBody() const
11670 {
11671         return "#version 400\n"
11672                    "\n"
11673                    "#extension GL_ARB_shader_subroutine : require\n"
11674                    "\n"
11675                    "subroutine void testSubroutineType(inout vec4 test);\n"
11676                    "\n"
11677                    "void testSubroutine1(inout vec4 test)\n"
11678                    "{\n"
11679                    "    test += vec4(0, 1, 2, 3);\n"
11680                    "}\n"
11681                    "\n"
11682                    "uniform testSubroutineType subroutineFunction;\n"
11683                    "\n"
11684                    "void main()\n"
11685                    "{\n"
11686                    "    subroutineFunction(gl_Position);\n"
11687                    "}\n";
11688 }
11689
11690 /** Executes test iteration.
11691  *
11692  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
11693  */
11694 tcu::TestNode::IterateResult NegativeTest3::iterate()
11695 {
11696         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
11697         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
11698         {
11699                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
11700         }
11701
11702         /* Iterate over all shader stages */
11703         for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
11704                  shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage)
11705         {
11706                 executeTest(static_cast<Utils::_shader_stage>(shader_stage));
11707         } /* for (all shader stages) */
11708
11709         /* Done */
11710         if (m_has_test_passed)
11711         {
11712                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
11713         }
11714         else
11715         {
11716                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
11717         }
11718
11719         return STOP;
11720 }
11721
11722 /** Constructor.
11723  *
11724  *  @param context Rendering context.
11725  *
11726  **/
11727 NegativeTest4::NegativeTest4(deqp::Context& context)
11728         : TestCase(context, "subroutines_incompatible_with_subroutine_type",
11729                            "Verifies that a compile-time error is generated when arguments and "
11730                            "return type do not match beween the function and each associated "
11731                            "subroutine type.")
11732         , m_has_test_passed(true)
11733         , m_so_id(0)
11734 {
11735         /* Left blank intentionally */
11736 }
11737
11738 /** Deinitializes GL objects that may have been created during test
11739  *  execution.
11740  **/
11741 void NegativeTest4::deinit()
11742 {
11743         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11744
11745         if (m_so_id != 0)
11746         {
11747                 gl.deleteShader(m_so_id);
11748
11749                 m_so_id = 0;
11750         }
11751 }
11752
11753 /** Retrieves body of a shader of user-specified type that should be used
11754  *  for a single test iteration. The shader will define user-specified number
11755  *  of subroutine types, with the last type either defining an additional argument
11756  *  or using a different return type.
11757  *  A subroutine (claimed compatible with *all* subroutine types) will also be
11758  *  defined in the shader.
11759  *
11760  *  @param shader_stage       Shader stage to use for the query.
11761  *  @param n_subroutine_types Overall number of subroutine types that will be
11762  *                            declared & used in the shader. Please see description
11763  *                            for more details.
11764  *
11765  *  @return Requested string.
11766  **/
11767 std::string NegativeTest4::getShaderBody(const Utils::_shader_stage& shader_stage,
11768                                                                                  const unsigned int& n_subroutine_types, const _test_case& test_case) const
11769 {
11770         std::stringstream result_sstream;
11771
11772         /* Form the pre-amble */
11773         result_sstream << "#version 400\n"
11774                                           "\n"
11775                                           "#extension GL_ARB_shader_subroutine : require\n"
11776                                           "\n";
11777
11778         /* Inject stage-specific code */
11779         switch (shader_stage)
11780         {
11781         case Utils::SHADER_STAGE_GEOMETRY:
11782         {
11783                 result_sstream << "layout (points) in;\n"
11784                                                   "layout (points, max_vertices = 1) out;\n"
11785                                                   "\n";
11786
11787                 break;
11788         }
11789
11790         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
11791         {
11792                 result_sstream << "layout (vertices = 4) out;\n"
11793                                                   "\n";
11794
11795                 break;
11796         }
11797
11798         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
11799         {
11800                 result_sstream << "layout (quads) in;\n"
11801                                                   "\n";
11802
11803                 break;
11804         }
11805
11806         default:
11807                 break;
11808         } /* switch (shader_stage) */
11809
11810         /* Insert subroutine type declarations */
11811         for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types - 1; ++n_subroutine_type)
11812         {
11813                 result_sstream << "subroutine void subroutineType" << n_subroutine_type << "(inout vec3 argument);\n";
11814         } /* for (all subroutine types) */
11815
11816         switch (test_case)
11817         {
11818         case TEST_CASE_INCOMPATIBLE_ARGUMENT_LIST:
11819         {
11820                 result_sstream << "subroutine void subroutineType" << (n_subroutine_types - 1)
11821                                            << "(inout vec3 argument, out vec4 argument2);\n";
11822
11823                 break;
11824         }
11825
11826         case TEST_CASE_INCOMPATIBLE_RETURN_TYPE:
11827         {
11828                 result_sstream << "subroutine int subroutineType" << (n_subroutine_types - 1) << "(inout vec3 argument);\n";
11829
11830                 break;
11831         }
11832
11833         default:
11834         {
11835                 TCU_FAIL("Unrecognized test case");
11836         }
11837         } /* switch (test_case) */
11838
11839         /* Insert subroutine declarations */
11840         result_sstream << "subroutine(";
11841
11842         for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types; ++n_subroutine_type)
11843         {
11844                 result_sstream << "subroutineType" << n_subroutine_type;
11845
11846                 if (n_subroutine_type != (n_subroutine_types - 1))
11847                 {
11848                         result_sstream << ", ";
11849                 }
11850         } /* for (all subroutine types) */
11851
11852         result_sstream << ") void function(inout vec3 argument)\n"
11853                                           "{\n"
11854                                           "    argument = vec3(1, 2, 3);\n"
11855                                           "}\n"
11856                                           "\n";
11857
11858         /* Insert remaining required stage-specific bits */
11859         switch (shader_stage)
11860         {
11861         case Utils::SHADER_STAGE_FRAGMENT:
11862         {
11863                 result_sstream << "out vec4 result;\n"
11864                                                   "\n"
11865                                                   "void main()\n"
11866                                                   "{\n"
11867                                                   "    result = vec4(1, 2, 3, 4);\n"
11868                                                   "}\n";
11869
11870                 break;
11871         }
11872
11873         case Utils::SHADER_STAGE_GEOMETRY:
11874         {
11875                 result_sstream << "void main()\n"
11876                                                   "{\n"
11877                                                   "    gl_Position = vec4(1, 2, 3, 4);\n"
11878                                                   "    EmitVertex();\n"
11879                                                   "}\n";
11880
11881                 break;
11882         }
11883
11884         case Utils::SHADER_STAGE_TESSELLATION_CONTROL:
11885         {
11886                 result_sstream << "void main()\n"
11887                                                   "{\n"
11888                                                   "    gl_TessLevelInner[0]                = 1;\n"
11889                                                   "    gl_TessLevelInner[1]                = 1;\n"
11890                                                   "    gl_TessLevelOuter[0]                = 1;\n"
11891                                                   "    gl_TessLevelOuter[1]                = 1;\n"
11892                                                   "    gl_TessLevelOuter[2]                = 1;\n"
11893                                                   "    gl_TessLevelOuter[3]                = 1;\n"
11894                                                   "    gl_out[gl_InvocationID].gl_Position = vec4(2, 3, 4, 5);\n"
11895                                                   "}\n";
11896
11897                 break;
11898         }
11899
11900         case Utils::SHADER_STAGE_TESSELLATION_EVALUATION:
11901         case Utils::SHADER_STAGE_VERTEX:
11902         {
11903                 result_sstream << "void main()\n"
11904                                                   "{\n"
11905                                                   "    gl_Position = vec4(1, 2, 3, 4);\n"
11906                                                   "}\n";
11907
11908                 break;
11909         }
11910
11911         default:
11912         {
11913                 TCU_FAIL("Unrecognized shader stage");
11914         }
11915         } /* switch (shader_stage) */
11916
11917         return result_sstream.str();
11918 }
11919
11920 /** Executes test iteration.
11921  *
11922  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
11923  */
11924 tcu::TestNode::IterateResult NegativeTest4::iterate()
11925 {
11926         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
11927
11928         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
11929         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
11930         {
11931                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
11932         }
11933
11934         /* Iterate over all shader stages.. */
11935         for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
11936                  shader_stage != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage)
11937         {
11938                 /* For each shader stage, we will be trying to compile a number of invalid shaders.
11939                  * Each shader defines N different subroutine types. (N-1) of them are compatible
11940                  * with a subroutine, but exactly 1 will be mismatched. The test passes if GLSL
11941                  * compiler correctly detects that all shaders we will be trying to compile are
11942                  * broken.
11943                  */
11944                 const glw::GLenum shader_type = Utils::getGLenumForShaderStage(static_cast<Utils::_shader_stage>(shader_stage));
11945
11946                 for (unsigned int n_subroutine_types = 1; n_subroutine_types < 6; /* arbitrary number */
11947                          ++n_subroutine_types)
11948                 {
11949                         for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT);
11950                                  ++test_case)
11951                         {
11952                                 std::string body;
11953                                 const char* body_raw_ptr   = NULL;
11954                                 glw::GLint  compile_status = GL_FALSE;
11955
11956                                 body = getShaderBody(static_cast<Utils::_shader_stage>(shader_stage), n_subroutine_types,
11957                                                                          static_cast<_test_case>(test_case));
11958                                 body_raw_ptr = body.c_str();
11959
11960                                 /* Try to compile the shader */
11961                                 m_so_id = gl.createShader(shader_type);
11962                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed");
11963
11964                                 gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL);
11965                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed");
11966
11967                                 gl.compileShader(m_so_id);
11968                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed");
11969
11970                                 gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status);
11971                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
11972
11973                                 if (compile_status == GL_TRUE)
11974                                 {
11975                                         m_testCtx.getLog() << tcu::TestLog::Message << "A malformed "
11976                                                                            << Utils::getShaderStageString(static_cast<Utils::_shader_stage>(shader_stage))
11977                                                                            << " compiled successfully "
11978                                                                                   "("
11979                                                                            << n_subroutine_types << " subroutine types "
11980                                                                                                                                 "were defined)."
11981                                                                            << tcu::TestLog::EndMessage;
11982
11983                                         m_has_test_passed = false;
11984                                 }
11985
11986                                 /* Release the object */
11987                                 gl.deleteShader(m_so_id);
11988                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed.");
11989                         } /* for (all test cases) */
11990                 }        /* for (a number of different subroutine type declarations) */
11991         }                 /* for (all shader stages) */
11992
11993         /* Done */
11994         if (m_has_test_passed)
11995         {
11996                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
11997         }
11998         else
11999         {
12000                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
12001         }
12002
12003         return STOP;
12004 }
12005
12006 /** Constructor.
12007  *
12008  *  @param context Rendering context.
12009  *
12010  **/
12011 NegativeTest5::NegativeTest5(deqp::Context& context)
12012         : TestCase(context, "subroutine_uniform_wo_matching_subroutines",
12013                            "Verifies that a link- or compile-time error occurs when "
12014                            "trying to link a program with no subroutine for subroutine "
12015                            "uniform variable.")
12016         , m_fs_id(0)
12017         , m_gs_id(0)
12018         , m_has_test_passed(true)
12019         , m_po_id(0)
12020         , m_tc_id(0)
12021         , m_te_id(0)
12022         , m_vs_id(0)
12023 {
12024         /* Left blank intentionally */
12025 }
12026
12027 /** Deinitializes all GL objects that may have been created during test execution */
12028 void NegativeTest5::deinit()
12029 {
12030         deinitIteration();
12031 }
12032
12033 /** Deinitializes all GL objects that may have been created during a single test
12034  *  iteration.
12035  ***/
12036 void NegativeTest5::deinitIteration()
12037 {
12038         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
12039
12040         if (m_fs_id != 0)
12041         {
12042                 gl.deleteShader(m_fs_id);
12043
12044                 m_fs_id = 0;
12045         }
12046
12047         if (m_gs_id != 0)
12048         {
12049                 gl.deleteShader(m_gs_id);
12050
12051                 m_gs_id = 0;
12052         }
12053
12054         if (m_po_id != 0)
12055         {
12056                 gl.deleteProgram(m_po_id);
12057
12058                 m_po_id = 0;
12059         }
12060
12061         if (m_tc_id != 0)
12062         {
12063                 gl.deleteShader(m_tc_id);
12064
12065                 m_tc_id = 0;
12066         }
12067
12068         if (m_te_id != 0)
12069         {
12070                 gl.deleteShader(m_te_id);
12071
12072                 m_te_id = 0;
12073         }
12074
12075         if (m_vs_id != 0)
12076         {
12077                 gl.deleteShader(m_vs_id);
12078
12079                 m_vs_id = 0;
12080         }
12081 }
12082
12083 /** Executes a single test iteration.
12084  *
12085  *  If the iteration fails, m_has_test_passed will be set to false.
12086  *
12087  *  @param shader_stage Shader stage, for which a subroutine uniform should be
12088  *                      declared in the shader without a matching subroutine.
12089  **/
12090 void NegativeTest5::executeIteration(const Utils::_shader_stage& shader_stage)
12091 {
12092         std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT);
12093         std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY);
12094         std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL);
12095         std::string te_body =
12096                 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION);
12097         std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX);
12098
12099         if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body,
12100                                                         DE_NULL, /* xfb_varyings */
12101                                                         DE_NULL, /* n_xfb_varyings */
12102                                                         &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id))
12103         {
12104                 /* None of the test programs should ever build successfully */
12105                 m_testCtx.getLog() << tcu::TestLog::Message
12106                                                    << "A program object, consisting of the following shaders, has linked"
12107                                                           " correctly. One of the shaders defines a subroutine uniform but does "
12108                                                           "not implement any function that matches subroutine type of the uniform."
12109                                                           " This should have resulted in a compilation/link-time error.\n"
12110                                                           "\n"
12111                                                           "Vertex shader:\n"
12112                                                           "\n"
12113                                                    << vs_body << "\n"
12114                                                                                  "Tessellation control shader:\n"
12115                                                                                  "\n"
12116                                                    << tc_body << "\n"
12117                                                                                  "Tessellation evaluation shader:\n"
12118                                                                                  "\n"
12119                                                    << te_body << "\n"
12120                                                                                  "Geometry shader:\n"
12121                                                                                  "\n"
12122                                                    << gs_body << "\n"
12123                                                                                  "Fragment shader:\n"
12124                                                                                  "\n"
12125                                                    << fs_body << tcu::TestLog::EndMessage;
12126
12127                 m_has_test_passed = false;
12128         }
12129 }
12130
12131 /** Retrieves fragment shader body.
12132  *
12133  *  @param include_invalid_subroutine_uniform_declaration true if the shader should declare
12134  *                                                        a subroutine uniform without
12135  *                                                        a matching subroutine, false otherwise.
12136  *
12137  *  @return Requested string.
12138  **/
12139 std::string NegativeTest5::getFragmentShaderBody(bool include_invalid_subroutine_uniform_declaration) const
12140 {
12141         std::stringstream result_sstream;
12142
12143         result_sstream << "#version 400\n"
12144                                           "\n"
12145                                           "#extension GL_ARB_shader_subroutine : require\n"
12146                                           "\n";
12147
12148         if (include_invalid_subroutine_uniform_declaration)
12149         {
12150                 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n"
12151                                                   "\n"
12152                                                   "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
12153         };
12154
12155         result_sstream << "\n"
12156                                           "out vec4 result;\n"
12157                                           "\n"
12158                                           "void main()\n"
12159                                           "{\n";
12160
12161         if (include_invalid_subroutine_uniform_declaration)
12162         {
12163                 result_sstream << "    test_subroutineFS(result);\n";
12164         }
12165         else
12166         {
12167                 result_sstream << "    result = vec4(0, 1, 2, 3);\n";
12168         }
12169
12170         result_sstream << "}\n";
12171
12172         return result_sstream.str();
12173 }
12174
12175 /** Retrieves geometry shader body.
12176  *
12177  *  @param include_invalid_subroutine_uniform_declaration true if the shader should declare
12178  *                                                        a subroutine uniform without
12179  *                                                        a matching subroutine, false otherwise.
12180  *
12181  *  @return Requested string.
12182  **/
12183 std::string NegativeTest5::getGeometryShaderBody(bool include_invalid_subroutine_uniform_declaration) const
12184 {
12185         std::stringstream result_sstream;
12186
12187         result_sstream << "#version 400\n"
12188                                           "\n"
12189                                           "#extension GL_ARB_shader_subroutine : require\n"
12190                                           "\n"
12191                                           "layout (points)                   in;\n"
12192                                           "layout (points, max_vertices = 1) out;\n"
12193                                           "\n";
12194
12195         if (include_invalid_subroutine_uniform_declaration)
12196         {
12197                 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n"
12198                                                   "\n"
12199                                                   "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
12200         };
12201
12202         result_sstream << "\n"
12203                                           "void main()\n"
12204                                           "{\n";
12205
12206         if (include_invalid_subroutine_uniform_declaration)
12207         {
12208                 result_sstream << "    test_subroutineGS(gl_Position);\n";
12209         }
12210         else
12211         {
12212                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12213         }
12214
12215         result_sstream << "EmitVertex();\n"
12216                                           "}\n";
12217
12218         return result_sstream.str();
12219 }
12220
12221 /** Retrieves tessellation control shader body.
12222  *
12223  *  @param include_invalid_subroutine_uniform_declaration true if the shader should declare
12224  *                                                        a subroutine uniform without
12225  *                                                        a matching subroutine, false otherwise.
12226  *
12227  *  @return Requested string.
12228  **/
12229 std::string NegativeTest5::getTessellationControlShaderBody(bool include_invalid_subroutine_uniform_declaration) const
12230 {
12231         std::stringstream result_sstream;
12232
12233         result_sstream << "#version 400\n"
12234                                           "\n"
12235                                           "#extension GL_ARB_shader_subroutine : require\n"
12236                                           "\n"
12237                                           "layout (vertices = 4) out;\n"
12238                                           "\n";
12239
12240         if (include_invalid_subroutine_uniform_declaration)
12241         {
12242                 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n"
12243                                                   "\n"
12244                                                   "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
12245         };
12246
12247         result_sstream << "\n"
12248                                           "void main()\n"
12249                                           "{\n";
12250
12251         if (include_invalid_subroutine_uniform_declaration)
12252         {
12253                 result_sstream << "    test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n";
12254         }
12255         else
12256         {
12257                 result_sstream << "    gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n";
12258         }
12259
12260         result_sstream << "}\n";
12261
12262         return result_sstream.str();
12263 }
12264
12265 /** Retrieves tessellation evaluation body.
12266  *
12267  *  @param include_invalid_subroutine_uniform_declaration true if the shader should declare
12268  *                                                        a subroutine uniform without
12269  *                                                        a matching subroutine, false otherwise.
12270  *
12271  *  @return Requested string.
12272  **/
12273 std::string NegativeTest5::getTessellationEvaluationShaderBody(
12274         bool include_invalid_subroutine_uniform_declaration) const
12275 {
12276         std::stringstream result_sstream;
12277
12278         result_sstream << "#version 400\n"
12279                                           "\n"
12280                                           "#extension GL_ARB_shader_subroutine : require\n"
12281                                           "\n"
12282                                           "layout (quads) in;\n"
12283                                           "\n";
12284
12285         if (include_invalid_subroutine_uniform_declaration)
12286         {
12287                 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n"
12288                                                   "\n"
12289                                                   "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
12290         };
12291
12292         result_sstream << "\n"
12293                                           "void main()\n"
12294                                           "{\n";
12295
12296         if (include_invalid_subroutine_uniform_declaration)
12297         {
12298                 result_sstream << "    test_subroutineTE(gl_Position);\n";
12299         }
12300         else
12301         {
12302                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12303         }
12304
12305         result_sstream << "}\n";
12306
12307         return result_sstream.str();
12308 }
12309
12310 /** Retrieves vertex shader body.
12311  *
12312  *  @param include_invalid_subroutine_uniform_declaration true if the shader should declare
12313  *                                                        a subroutine uniform without
12314  *                                                        a matching subroutine, false otherwise.
12315  *
12316  *  @return Requested string.
12317  **/
12318 std::string NegativeTest5::getVertexShaderBody(bool include_invalid_subroutine_uniform_declaration) const
12319 {
12320         std::stringstream result_sstream;
12321
12322         result_sstream << "#version 400\n"
12323                                           "\n"
12324                                           "#extension GL_ARB_shader_subroutine : require\n"
12325                                           "\n";
12326
12327         if (include_invalid_subroutine_uniform_declaration)
12328         {
12329                 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n"
12330                                                   "\n"
12331                                                   "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
12332         };
12333
12334         result_sstream << "\n"
12335                                           "void main()\n"
12336                                           "{\n";
12337
12338         if (include_invalid_subroutine_uniform_declaration)
12339         {
12340                 result_sstream << "    test_subroutineVS(gl_Position);\n";
12341         }
12342         else
12343         {
12344                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12345         }
12346
12347         result_sstream << "}\n";
12348
12349         return result_sstream.str();
12350 }
12351
12352 /** Executes test iteration.
12353  *
12354  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
12355  */
12356 tcu::TestNode::IterateResult NegativeTest5::iterate()
12357 {
12358         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
12359         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
12360         {
12361                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
12362         }
12363
12364         /* Iterate over all shader stages. Iteration-specific shader stage defines a subroutine type &
12365          * a corresponding subroutine uniform, for which no compatible subroutines are available. All
12366          * other shader stages are defined correctly.
12367          */
12368         for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
12369                  shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage)
12370         {
12371                 executeIteration(static_cast<Utils::_shader_stage>(shader_stage));
12372                 deinitIteration();
12373         } /* for (all shader stages) */
12374
12375         /* All done */
12376         if (m_has_test_passed)
12377         {
12378                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
12379         }
12380         else
12381         {
12382                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
12383         }
12384
12385         return STOP;
12386 }
12387
12388 /** Constructor.
12389  *
12390  *  @param context Rendering context.
12391  *
12392  **/
12393 NegativeTest6::NegativeTest6(deqp::Context& context)
12394         : TestCase(context, "two_duplicate_functions_one_being_a_subroutine",
12395                            "Verifies that a link- or compile-time error occurs if any shader in "
12396                            "a program object includes two functions with the same name and one "
12397                            "of which is associated with a subroutine type.")
12398         , m_fs_id(0)
12399         , m_gs_id(0)
12400         , m_has_test_passed(true)
12401         , m_po_id(0)
12402         , m_tc_id(0)
12403         , m_te_id(0)
12404         , m_vs_id(0)
12405 {
12406         /* Left blank intentionally */
12407 }
12408
12409 /** Deinitializes all GL objects that may have been created during test execution */
12410 void NegativeTest6::deinit()
12411 {
12412         deinitIteration();
12413 }
12414
12415 /** Deinitializes all GL objects that may have been created during a single test
12416  *  iteration.
12417  ***/
12418 void NegativeTest6::deinitIteration()
12419 {
12420         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
12421
12422         if (m_fs_id != 0)
12423         {
12424                 gl.deleteShader(m_fs_id);
12425
12426                 m_fs_id = 0;
12427         }
12428
12429         if (m_gs_id != 0)
12430         {
12431                 gl.deleteShader(m_gs_id);
12432
12433                 m_gs_id = 0;
12434         }
12435
12436         if (m_po_id != 0)
12437         {
12438                 gl.deleteProgram(m_po_id);
12439
12440                 m_po_id = 0;
12441         }
12442
12443         if (m_tc_id != 0)
12444         {
12445                 gl.deleteShader(m_tc_id);
12446
12447                 m_tc_id = 0;
12448         }
12449
12450         if (m_te_id != 0)
12451         {
12452                 gl.deleteShader(m_te_id);
12453
12454                 m_te_id = 0;
12455         }
12456
12457         if (m_vs_id != 0)
12458         {
12459                 gl.deleteShader(m_vs_id);
12460
12461                 m_vs_id = 0;
12462         }
12463 }
12464
12465 /** Executes a single test iteration.
12466  *
12467  *  If the iteration fails, m_has_test_passed will be set to false.
12468  *
12469  *  @param shader_stage Shader stage, for which two duplicate functions
12470  *                      (one additionally marked as subroutine) should
12471  *                      be defined.
12472  **/
12473 void NegativeTest6::executeIteration(const Utils::_shader_stage& shader_stage)
12474 {
12475         std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT);
12476         std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY);
12477         std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL);
12478         std::string te_body =
12479                 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION);
12480         std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX);
12481
12482         if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body,
12483                                                         DE_NULL, /* xfb_varyings */
12484                                                         DE_NULL, /* n_xfb_varyings */
12485                                                         &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id))
12486         {
12487                 /* None of the test programs should ever build successfully */
12488                 m_testCtx.getLog() << tcu::TestLog::Message
12489                                                    << "A program object, consisting of the following shaders, has linked"
12490                                                           " correctly. This is invalid, because one of the shaders defines two"
12491                                                           " functions with the same name, with an exception that one of the"
12492                                                           " functions is marked as a subroutine.\n"
12493                                                           "\n"
12494                                                           "Vertex shader:\n"
12495                                                           "\n"
12496                                                    << vs_body << "\n"
12497                                                                                  "Tessellation control shader:\n"
12498                                                                                  "\n"
12499                                                    << tc_body << "\n"
12500                                                                                  "Tessellation evaluation shader:\n"
12501                                                                                  "\n"
12502                                                    << te_body << "\n"
12503                                                                                  "Geometry shader:\n"
12504                                                                                  "\n"
12505                                                    << gs_body << "\n"
12506                                                                                  "Fragment shader:\n"
12507                                                                                  "\n"
12508                                                    << fs_body << tcu::TestLog::EndMessage;
12509
12510                 m_has_test_passed = false;
12511         }
12512 }
12513
12514 /** Retrieves fragment shader body.
12515  *
12516  *  @param include_invalid_declaration true if the shader should include duplicate function
12517  *                                     declaration.
12518  *
12519  *  @return Requested string.
12520  **/
12521 std::string NegativeTest6::getFragmentShaderBody(bool include_invalid_declaration) const
12522 {
12523         std::stringstream result_sstream;
12524
12525         result_sstream << "#version 400\n"
12526                                           "\n"
12527                                           "#extension GL_ARB_shader_subroutine : require\n"
12528                                           "\n";
12529
12530         if (include_invalid_declaration)
12531         {
12532                 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n"
12533                                                   "\n"
12534                                                   "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test)\n"
12535                                                   "{\n"
12536                                                   "    test = vec4(1, 2, 3, 4);\n"
12537                                                   "}\n"
12538                                                   "\n"
12539                                                   "void test_impl1(out vec4 test)\n"
12540                                                   "{\n"
12541                                                   "    test = vec4(2, 3, 4, 5);\n"
12542                                                   "}\n"
12543                                                   "\n"
12544                                                   "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
12545         };
12546
12547         result_sstream << "\n"
12548                                           "out vec4 result;\n"
12549                                           "\n"
12550                                           "void main()\n"
12551                                           "{\n";
12552
12553         if (include_invalid_declaration)
12554         {
12555                 result_sstream << "    test_subroutineFS(result);\n";
12556         }
12557         else
12558         {
12559                 result_sstream << "    result = vec4(0, 1, 2, 3);\n";
12560         }
12561
12562         result_sstream << "}\n";
12563
12564         return result_sstream.str();
12565 }
12566
12567 /** Retrieves geometry shader body.
12568  *
12569  *  @param include_invalid_declaration true if the shader should include duplicate function
12570  *                                     declaration.
12571  *
12572  *  @return Requested string.
12573  **/
12574 std::string NegativeTest6::getGeometryShaderBody(bool include_invalid_declaration) const
12575 {
12576         std::stringstream result_sstream;
12577
12578         result_sstream << "#version 400\n"
12579                                           "\n"
12580                                           "#extension GL_ARB_shader_subroutine : require\n"
12581                                           "\n"
12582                                           "layout (points)                   in;\n"
12583                                           "layout (points, max_vertices = 1) out;\n"
12584                                           "\n";
12585
12586         if (include_invalid_declaration)
12587         {
12588                 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n"
12589                                                   "\n"
12590                                                   "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test)\n"
12591                                                   "{\n"
12592                                                   "    test = vec4(1, 2, 3, 4);\n"
12593                                                   "}\n"
12594                                                   "\n"
12595                                                   "void test_impl1(out vec4 test)\n"
12596                                                   "{\n"
12597                                                   "    test = vec4(2, 3, 4, 5);\n"
12598                                                   "}\n"
12599                                                   "\n"
12600                                                   "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
12601         };
12602
12603         result_sstream << "\n"
12604                                           "void main()\n"
12605                                           "{\n";
12606
12607         if (include_invalid_declaration)
12608         {
12609                 result_sstream << "    test_subroutineGS(gl_Position);\n";
12610         }
12611         else
12612         {
12613                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12614         }
12615
12616         result_sstream << "EmitVertex();\n"
12617                                           "}\n";
12618
12619         return result_sstream.str();
12620 }
12621
12622 /** Retrieves tessellation control shader body.
12623  *
12624  *  @param include_invalid_declaration true if the shader should include duplicate function
12625  *                                     declaration.
12626  *
12627  *  @return Requested string.
12628  **/
12629 std::string NegativeTest6::getTessellationControlShaderBody(bool include_invalid_declaration) const
12630 {
12631         std::stringstream result_sstream;
12632
12633         result_sstream << "#version 400\n"
12634                                           "\n"
12635                                           "#extension GL_ARB_shader_subroutine : require\n"
12636                                           "\n"
12637                                           "layout (vertices = 4) out;\n"
12638                                           "\n";
12639
12640         if (include_invalid_declaration)
12641         {
12642                 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n"
12643                                                   "\n"
12644                                                   "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test)\n"
12645                                                   "{\n"
12646                                                   "    test = vec4(1, 2, 3, 4);\n"
12647                                                   "}\n"
12648                                                   "\n"
12649                                                   "void test_impl1(out vec4 test)\n"
12650                                                   "{\n"
12651                                                   "    test = vec4(2, 3, 4, 5);\n"
12652                                                   "}\n"
12653                                                   "\n"
12654                                                   "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
12655         };
12656
12657         result_sstream << "\n"
12658                                           "void main()\n"
12659                                           "{\n";
12660
12661         if (include_invalid_declaration)
12662         {
12663                 result_sstream << "    test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n";
12664         }
12665         else
12666         {
12667                 result_sstream << "    gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n";
12668         }
12669
12670         result_sstream << "}\n";
12671
12672         return result_sstream.str();
12673 }
12674
12675 /** Retrieves tessellation evaluation body.
12676  *
12677  *  @param include_invalid_declaration true if the shader should include duplicate function
12678  *                                     declaration.
12679  *
12680  *  @return Requested string.
12681  **/
12682 std::string NegativeTest6::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const
12683 {
12684         std::stringstream result_sstream;
12685
12686         result_sstream << "#version 400\n"
12687                                           "\n"
12688                                           "#extension GL_ARB_shader_subroutine : require\n"
12689                                           "\n"
12690                                           "layout (quads) in;\n"
12691                                           "\n";
12692
12693         if (include_invalid_declaration)
12694         {
12695                 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n"
12696                                                   "\n"
12697                                                   "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test)\n"
12698                                                   "{\n"
12699                                                   "    test = vec4(1, 2, 3, 4);\n"
12700                                                   "}\n"
12701                                                   "\n"
12702                                                   "void test_impl1(out vec4 test)\n"
12703                                                   "{\n"
12704                                                   "    test = vec4(2, 3, 4, 5);\n"
12705                                                   "}\n"
12706                                                   "\n"
12707                                                   "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
12708         };
12709
12710         result_sstream << "\n"
12711                                           "void main()\n"
12712                                           "{\n";
12713
12714         if (include_invalid_declaration)
12715         {
12716                 result_sstream << "    test_subroutineTE(gl_Position);\n";
12717         }
12718         else
12719         {
12720                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12721         }
12722
12723         result_sstream << "}\n";
12724
12725         return result_sstream.str();
12726 }
12727
12728 /** Retrieves vertex shader body.
12729  *
12730  *  @param include_invalid_declaration true if the shader should include duplicate function
12731  *                                     declaration.
12732  *
12733  *  @return Requested string.
12734  **/
12735 std::string NegativeTest6::getVertexShaderBody(bool include_invalid_declaration) const
12736 {
12737         std::stringstream result_sstream;
12738
12739         result_sstream << "#version 400\n"
12740                                           "\n"
12741                                           "#extension GL_ARB_shader_subroutine : require\n"
12742                                           "\n";
12743
12744         if (include_invalid_declaration)
12745         {
12746                 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n"
12747                                                   "\n"
12748                                                   "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test)\n"
12749                                                   "{\n"
12750                                                   "    test = vec4(1, 2, 3, 4);\n"
12751                                                   "}\n"
12752                                                   "\n"
12753                                                   "void test_impl1(out vec4 test)\n"
12754                                                   "{\n"
12755                                                   "    test = vec4(2, 3, 4, 5);\n"
12756                                                   "}\n"
12757                                                   "\n"
12758                                                   "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
12759         };
12760
12761         result_sstream << "\n"
12762                                           "void main()\n"
12763                                           "{\n";
12764
12765         if (include_invalid_declaration)
12766         {
12767                 result_sstream << "    test_subroutineVS(gl_Position);\n";
12768         }
12769         else
12770         {
12771                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
12772         }
12773
12774         result_sstream << "}\n";
12775
12776         return result_sstream.str();
12777 }
12778
12779 /** Executes test iteration.
12780  *
12781  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
12782  */
12783 tcu::TestNode::IterateResult NegativeTest6::iterate()
12784 {
12785         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
12786         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
12787         {
12788                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
12789         }
12790
12791         /* Iterate over all shader stages. In each iteration, we will inject invalid
12792          * duplicate function declarations to iteration-specific shader stage. All other
12793          * shader stages will be assigned valid bodies. Test should fail if the program
12794          * links successfully.
12795          */
12796         for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
12797                  shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage)
12798         {
12799                 executeIteration(static_cast<Utils::_shader_stage>(shader_stage));
12800                 deinitIteration();
12801         } /* for (all shader stages) */
12802
12803         /* All done */
12804         if (m_has_test_passed)
12805         {
12806                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
12807         }
12808         else
12809         {
12810                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
12811         }
12812
12813         return STOP;
12814 }
12815
12816 /** Constructor
12817  *
12818  * @param context CTS context
12819  **/
12820 NegativeTest7::NegativeTest7(deqp::Context& context)
12821         : TestCase(context, "recursion", "Verify that it is not possible to build program with recursing subroutines")
12822         , m_program_id(0)
12823         , m_vertex_shader_id(0)
12824 {
12825         /* Nothing to be done here */
12826 }
12827
12828 /** Deinitializes all GL objects that may have been created during test execution
12829  *
12830  **/
12831 void NegativeTest7::deinit()
12832 {
12833         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
12834
12835         if (m_program_id != 0)
12836         {
12837                 gl.deleteProgram(m_program_id);
12838
12839                 m_program_id = 0;
12840         }
12841
12842         if (m_vertex_shader_id != 0)
12843         {
12844                 gl.deleteShader(m_vertex_shader_id);
12845
12846                 m_vertex_shader_id = 0;
12847         }
12848 }
12849
12850 /** Executes test iteration.
12851  *
12852  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
12853  **/
12854 tcu::TestNode::IterateResult NegativeTest7::iterate()
12855 {
12856         static const GLchar* vertex_shader_with_static_recursion =
12857                 "#version 400\n"
12858                 "\n"
12859                 "#extension GL_ARB_shader_subroutine : require\n"
12860                 "\n"
12861                 "precision highp float;\n"
12862                 "\n"
12863                 "subroutine vec4 routine_type(in vec4 data, in uint control);\n"
12864                 "\n"
12865                 "subroutine (routine_type) vec4 power_routine(in vec4 data, in uint control)\n"
12866                 "{\n"
12867                 "    if (0 != control)\n"
12868                 "    {\n"
12869                 "        return data * power_routine(data, control - 1);\n"
12870                 "    }\n"
12871                 "    else\n"
12872                 "    {\n"
12873                 "        return vec4(1, 1, 1, 1);\n"
12874                 "    }\n"
12875                 "}\n"
12876                 "\n"
12877                 "subroutine (routine_type) vec4 select_routine(in vec4 data, in uint control)\n"
12878                 "{\n"
12879                 "    if (0 == control)\n"
12880                 "    {\n"
12881                 "        return data.rrrr;\n"
12882                 "    }\n"
12883                 "    else if (1 == control)\n"
12884                 "    {\n"
12885                 "        return data.gggg;\n"
12886                 "    }\n"
12887                 "    else if (2 == control)\n"
12888                 "    {\n"
12889                 "        return data.bbbb;\n"
12890                 "    }\n"
12891                 "    else\n"
12892                 "    {\n"
12893                 "        return data.aaaa;\n"
12894                 "    }\n"
12895                 "}\n"
12896                 "\n"
12897                 "subroutine uniform routine_type routine;\n"
12898                 "\n"
12899                 "uniform vec4 uni_value;\n"
12900                 "uniform uint uni_control;\n"
12901                 "\n"
12902                 "out vec4 out_result;\n"
12903                 "\n"
12904                 "void main()\n"
12905                 "{\n"
12906                 "    out_result = routine(uni_value, uni_control);\n"
12907                 "}\n"
12908                 "\n";
12909
12910         static const GLchar* vertex_shader_with_dynamic_recursion =
12911                 "#version 400\n"
12912                 "\n"
12913                 "#extension GL_ARB_shader_subroutine : require\n"
12914                 "\n"
12915                 "precision highp float;\n"
12916                 "\n"
12917                 "subroutine vec4 routine_type(in vec4 data);\n"
12918                 "\n"
12919                 "subroutine uniform routine_type routine;\n"
12920                 "\n"
12921                 "subroutine (routine_type) vec4 div_by_2(in vec4 data)\n"
12922                 "{\n"
12923                 "    return data / 2;\n"
12924                 "}\n"
12925                 "\n"
12926                 "subroutine (routine_type) vec4 div_routine_result_by_2(in vec4 data)\n"
12927                 "{\n"
12928                 "    return routine(data) / 2;\n"
12929                 "}\n"
12930                 "\n"
12931                 "uniform vec4 uni_value;\n"
12932                 "\n"
12933                 "out vec4 out_result;\n"
12934                 "\n"
12935                 "void main()\n"
12936                 "{\n"
12937                 "    out_result = routine(uni_value);\n"
12938                 "}\n"
12939                 "\n";
12940
12941         static const GLchar* vertex_shader_with_subroutine_function_recursion =
12942                 "#version 400\n"
12943                 "\n"
12944                 "#extension GL_ARB_shader_subroutine : require\n"
12945                 "\n"
12946                 "precision highp float;\n"
12947                 "\n"
12948                 "subroutine vec4 routine_type(in vec4 data);\n"
12949                 "\n"
12950                 "subroutine uniform routine_type routine;\n"
12951                 "\n"
12952                 "vec4 function(in vec4 data)\n"
12953                 "{\n"
12954                 "    return routine(data) + vec4(0.5, 0.5, 0.5, 0.5);\n"
12955                 "}\n"
12956                 "\n"
12957                 "subroutine (routine_type) vec4 routine_a(in vec4 data)\n"
12958                 "{\n"
12959                 "    return function(data) / 2;\n"
12960                 "}\n"
12961                 "\n"
12962                 "subroutine (routine_type) vec4 routine_b(in vec4 data)\n"
12963                 "{\n"
12964                 "    return routine_a(data) * 2;\n"
12965                 "}\n"
12966                 "\n"
12967                 "uniform vec4 uni_value;\n"
12968                 "\n"
12969                 "out vec4 out_result;\n"
12970                 "\n"
12971                 "void main()\n"
12972                 "{\n"
12973                 "    out_result = routine(uni_value);\n"
12974                 "}\n"
12975                 "\n";
12976
12977         bool result = true;
12978
12979         if (false == test(vertex_shader_with_subroutine_function_recursion, "routine_a"))
12980         {
12981                 result = false;
12982         }
12983
12984         if (false == test(vertex_shader_with_dynamic_recursion, "div_routine_result_by_2"))
12985         {
12986                 result = false;
12987         }
12988
12989         if (false == test(vertex_shader_with_static_recursion, "power_routine"))
12990         {
12991                 result = false;
12992         }
12993
12994         /* Set result */
12995         if (true == result)
12996         {
12997                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
12998         }
12999         else
13000         {
13001                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
13002         }
13003
13004         /* Done */
13005         return tcu::TestNode::STOP;
13006 }
13007
13008 /** Try to build program from vertex shader code.
13009  *
13010  * @param vertex_shader_code        Source code of vertex shader
13011  * @param name_of_recursive_routine Name of subroutine that should cause link failure due to recursion
13012  *
13013  * @return true build process failed, false otherwise
13014  **/
13015 bool NegativeTest7::test(const GLchar* vertex_shader_code, const GLchar* name_of_recursive_routine)
13016 {
13017         const glw::Functions& gl                   = m_context.getRenderContext().getFunctions();
13018         bool                              result           = true;
13019         static const GLchar*  varying_name = "out_result";
13020
13021         /* Try to build program */
13022         if (true == Utils::buildProgram(gl, vertex_shader_code, "", "", "", "", &varying_name /* varying_names */,
13023                                                                         1 /* n_varyings */, &m_vertex_shader_id, 0, 0, 0, 0, &m_program_id))
13024         {
13025                 /* Success is considered an error */
13026
13027                 Utils::program program(m_context);
13028                 GLuint             index = 0;
13029
13030                 program.build(0, 0, 0, 0, 0, vertex_shader_code, 0, 0);
13031
13032                 /* Verify that recursive subroutine is active */
13033                 try
13034                 {
13035                         index = program.getSubroutineIndex(name_of_recursive_routine, GL_VERTEX_SHADER);
13036                 }
13037                 catch (const std::exception& exc)
13038                 {
13039                         /* Something wrong with shader or compilation */
13040                         m_context.getTestContext().getLog()
13041                                 << tcu::TestLog::Message << "It is expected that subroutine: \n"
13042                                 << name_of_recursive_routine
13043                                 << " is considered active. This subroutine is potentially recursive and should cause link failure."
13044                                 << tcu::TestLog::EndMessage;
13045
13046                         throw exc;
13047                 }
13048
13049                 /* Subsoutine is active, however linking should fail */
13050                 m_context.getTestContext().getLog()
13051                         << tcu::TestLog::Message << "Error. Program with potentially recursive subroutine, "
13052                         << name_of_recursive_routine << ", which is active, index: " << index << ", has been built successfully.\n"
13053                         << vertex_shader_code << tcu::TestLog::EndMessage;
13054
13055                 result = false;
13056         }
13057
13058         /* Delete program and shader */
13059         deinit();
13060
13061         /* Done */
13062         return result;
13063 }
13064
13065 /** Constructor.
13066  *
13067  *  @param context Rendering context.
13068  *
13069  **/
13070 NegativeTest8::NegativeTest8(deqp::Context& context)
13071         : TestCase(context, "subroutine_wo_body", "Verifies that a compile- or link-time error occurs if a function "
13072                                                                                           "declared as a subroutine does not include a body.")
13073         , m_fs_id(0)
13074         , m_gs_id(0)
13075         , m_has_test_passed(true)
13076         , m_po_id(0)
13077         , m_tc_id(0)
13078         , m_te_id(0)
13079         , m_vs_id(0)
13080 {
13081         /* Left blank intentionally */
13082 }
13083
13084 /** Deinitializes all GL objects that may have been created during test execution */
13085 void NegativeTest8::deinit()
13086 {
13087         deinitIteration();
13088 }
13089
13090 /** Deinitializes all GL objects that may have been created during a single test
13091  *  iteration.
13092  ***/
13093 void NegativeTest8::deinitIteration()
13094 {
13095         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
13096
13097         if (m_fs_id != 0)
13098         {
13099                 gl.deleteShader(m_fs_id);
13100
13101                 m_fs_id = 0;
13102         }
13103
13104         if (m_gs_id != 0)
13105         {
13106                 gl.deleteShader(m_gs_id);
13107
13108                 m_gs_id = 0;
13109         }
13110
13111         if (m_po_id != 0)
13112         {
13113                 gl.deleteProgram(m_po_id);
13114
13115                 m_po_id = 0;
13116         }
13117
13118         if (m_tc_id != 0)
13119         {
13120                 gl.deleteShader(m_tc_id);
13121
13122                 m_tc_id = 0;
13123         }
13124
13125         if (m_te_id != 0)
13126         {
13127                 gl.deleteShader(m_te_id);
13128
13129                 m_te_id = 0;
13130         }
13131
13132         if (m_vs_id != 0)
13133         {
13134                 gl.deleteShader(m_vs_id);
13135
13136                 m_vs_id = 0;
13137         }
13138 }
13139
13140 /** Executes a single test iteration.
13141  *
13142  *  If the iteration fails, m_has_test_passed will be set to false.
13143  *
13144  *  @param shader_stage Shader stage, for which two duplicate functions
13145  *                      (one additionally marked as subroutine) should
13146  *                      be defined.
13147  **/
13148 void NegativeTest8::executeIteration(const Utils::_shader_stage& shader_stage)
13149 {
13150         std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT);
13151         std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY);
13152         std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL);
13153         std::string te_body =
13154                 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION);
13155         std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX);
13156
13157         if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body,
13158                                                         DE_NULL, /* xfb_varyings */
13159                                                         DE_NULL, /* n_xfb_varyings */
13160                                                         &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id))
13161         {
13162                 /* None of the test programs should ever build successfully */
13163                 m_testCtx.getLog() << tcu::TestLog::Message
13164                                                    << "A program object consisting of FS+GS+TC+TE+VS stages has linked successfully, "
13165                                                           "even though one of the shaders only defines a subroutine that lacks any body."
13166                                                           "\n"
13167                                                           "Vertex shader:\n"
13168                                                           "\n"
13169                                                    << vs_body << "\n"
13170                                                                                  "Tessellation control shader:\n"
13171                                                                                  "\n"
13172                                                    << tc_body << "\n"
13173                                                                                  "Tessellation evaluation shader:\n"
13174                                                                                  "\n"
13175                                                    << te_body << "\n"
13176                                                                                  "Geometry shader:\n"
13177                                                                                  "\n"
13178                                                    << gs_body << "\n"
13179                                                                                  "Fragment shader:\n"
13180                                                                                  "\n"
13181                                                    << fs_body << tcu::TestLog::EndMessage;
13182
13183                 m_has_test_passed = false;
13184         }
13185 }
13186
13187 /** Retrieves fragment shader body.
13188  *
13189  *  @param include_invalid_declaration true if a subroutine prototype should be included in
13190  *                                     the shader, false to skip it.
13191  *
13192  *  @return Requested string.
13193  **/
13194 std::string NegativeTest8::getFragmentShaderBody(bool include_invalid_declaration) const
13195 {
13196         std::stringstream result_sstream;
13197
13198         result_sstream << "#version 400\n"
13199                                           "\n"
13200                                           "#extension GL_ARB_shader_subroutine : require\n"
13201                                           "\n";
13202
13203         if (include_invalid_declaration)
13204         {
13205                 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n"
13206                                                   "\n"
13207                                                   "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test);\n"
13208                                                   "\n"
13209                                                   "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
13210         };
13211
13212         result_sstream << "\n"
13213                                           "out vec4 result;\n"
13214                                           "\n"
13215                                           "void main()\n"
13216                                           "{\n";
13217
13218         if (include_invalid_declaration)
13219         {
13220                 result_sstream << "    test_subroutineFS(result);\n";
13221         }
13222         else
13223         {
13224                 result_sstream << "    result = vec4(0, 1, 2, 3);\n";
13225         }
13226
13227         result_sstream << "}\n";
13228
13229         return result_sstream.str();
13230 }
13231
13232 /** Retrieves geometry shader body.
13233  *
13234  *  @param include_invalid_declaration true if a subroutine prototype should be included in
13235  *                                     the shader, false to skip it.
13236  *
13237  *  @return Requested string.
13238  **/
13239 std::string NegativeTest8::getGeometryShaderBody(bool include_invalid_declaration) const
13240 {
13241         std::stringstream result_sstream;
13242
13243         result_sstream << "#version 400\n"
13244                                           "\n"
13245                                           "#extension GL_ARB_shader_subroutine : require\n"
13246                                           "\n"
13247                                           "layout (points)                   in;\n"
13248                                           "layout (points, max_vertices = 1) out;\n"
13249                                           "\n";
13250
13251         if (include_invalid_declaration)
13252         {
13253                 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n"
13254                                                   "\n"
13255                                                   "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test);\n"
13256                                                   "\n"
13257                                                   "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
13258         };
13259
13260         result_sstream << "\n"
13261                                           "void main()\n"
13262                                           "{\n";
13263
13264         if (include_invalid_declaration)
13265         {
13266                 result_sstream << "    test_subroutineGS(gl_Position);\n";
13267         }
13268         else
13269         {
13270                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
13271         }
13272
13273         result_sstream << "EmitVertex();\n"
13274                                           "}\n";
13275
13276         return result_sstream.str();
13277 }
13278
13279 /** Retrieves tessellation control shader body.
13280  *
13281  *  @param include_invalid_declaration true if a subroutine prototype should be included in
13282  *                                     the shader, false to skip it.
13283  *
13284  *  @return Requested string.
13285  **/
13286 std::string NegativeTest8::getTessellationControlShaderBody(bool include_invalid_declaration) const
13287 {
13288         std::stringstream result_sstream;
13289
13290         result_sstream << "#version 400\n"
13291                                           "\n"
13292                                           "#extension GL_ARB_shader_subroutine : require\n"
13293                                           "\n"
13294                                           "layout (vertices = 4) out;\n"
13295                                           "\n";
13296
13297         if (include_invalid_declaration)
13298         {
13299                 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n"
13300                                                   "\n"
13301                                                   "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test);\n"
13302                                                   "\n"
13303                                                   "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
13304         };
13305
13306         result_sstream << "\n"
13307                                           "void main()\n"
13308                                           "{\n";
13309
13310         if (include_invalid_declaration)
13311         {
13312                 result_sstream << "    test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n";
13313         }
13314         else
13315         {
13316                 result_sstream << "    gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n";
13317         }
13318
13319         result_sstream << "}\n";
13320
13321         return result_sstream.str();
13322 }
13323
13324 /** Retrieves tessellation evaluation body.
13325  *
13326  *  @param include_invalid_declaration true if a subroutine prototype should be included in
13327  *                                     the shader, false to skip it.
13328  *
13329  *  @return Requested string.
13330  **/
13331 std::string NegativeTest8::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const
13332 {
13333         std::stringstream result_sstream;
13334
13335         result_sstream << "#version 400\n"
13336                                           "\n"
13337                                           "#extension GL_ARB_shader_subroutine : require\n"
13338                                           "\n"
13339                                           "layout (quads) in;\n"
13340                                           "\n";
13341
13342         if (include_invalid_declaration)
13343         {
13344                 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n"
13345                                                   "\n"
13346                                                   "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test);\n"
13347                                                   "\n"
13348                                                   "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
13349         };
13350
13351         result_sstream << "\n"
13352                                           "void main()\n"
13353                                           "{\n";
13354
13355         if (include_invalid_declaration)
13356         {
13357                 result_sstream << "    test_subroutineTE(gl_Position);\n";
13358         }
13359         else
13360         {
13361                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
13362         }
13363
13364         result_sstream << "}\n";
13365
13366         return result_sstream.str();
13367 }
13368
13369 /** Retrieves vertex shader body.
13370  *
13371  *  @param include_invalid_declaration true if a subroutine prototype should be included in
13372  *                                     the shader, false to skip it.
13373  *
13374  *  @return Requested string.
13375  **/
13376 std::string NegativeTest8::getVertexShaderBody(bool include_invalid_declaration) const
13377 {
13378         std::stringstream result_sstream;
13379
13380         result_sstream << "#version 400\n"
13381                                           "\n"
13382                                           "#extension GL_ARB_shader_subroutine : require\n"
13383                                           "\n";
13384
13385         if (include_invalid_declaration)
13386         {
13387                 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n"
13388                                                   "\n"
13389                                                   "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test);\n"
13390                                                   "\n"
13391                                                   "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
13392         };
13393
13394         result_sstream << "\n"
13395                                           "void main()\n"
13396                                           "{\n";
13397
13398         if (include_invalid_declaration)
13399         {
13400                 result_sstream << "    test_subroutineVS(gl_Position);\n";
13401         }
13402         else
13403         {
13404                 result_sstream << "    gl_Position = vec4(0, 1, 2, 3);\n";
13405         }
13406
13407         result_sstream << "}\n";
13408
13409         return result_sstream.str();
13410 }
13411
13412 /** Executes test iteration.
13413  *
13414  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
13415  */
13416 tcu::TestNode::IterateResult NegativeTest8::iterate()
13417 {
13418         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
13419         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
13420         {
13421                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
13422         }
13423
13424         /* Iterate over all shader stages. For each iteration, iteration-specific shader stage
13425          * will feature an invalid subroutine definition. Other shader stages will be assigned
13426          * valid bodies. The test fails if a program built of such shaders links successfully.
13427          */
13428         for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST);
13429                  shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage)
13430         {
13431                 executeIteration(static_cast<Utils::_shader_stage>(shader_stage));
13432                 deinitIteration();
13433         } /* for (all shader stages) */
13434
13435         /* All done */
13436         if (m_has_test_passed)
13437         {
13438                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
13439         }
13440         else
13441         {
13442                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
13443         }
13444
13445         return STOP;
13446 }
13447
13448 /** Constructor.
13449  *
13450  *  @param context Rendering context.
13451  **/
13452 NegativeTest9::NegativeTest9(deqp::Context& context)
13453         : TestCase(context, "subroutines_cannot_be_assigned_float_int_values_or_be_compared",
13454                            "Make sure it is not possible to assign float/int to subroutine "
13455                            "uniform and that subroutine uniform values cannot be compared.")
13456         , m_has_test_passed(true)
13457         , m_po_id(0)
13458         , m_vs_id(0)
13459 {
13460         /* Left blank intentionally */
13461 }
13462
13463 /** Deinitializes any GL objects that may have been created during
13464  *  test execution.
13465  **/
13466 void NegativeTest9::deinit()
13467 {
13468         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
13469
13470         if (m_po_id != 0)
13471         {
13472                 gl.deleteProgram(m_po_id);
13473
13474                 m_po_id = 0;
13475         }
13476
13477         if (m_vs_id != 0)
13478         {
13479                 gl.deleteShader(m_vs_id);
13480
13481                 m_vs_id = 0;
13482         }
13483 }
13484
13485 /** Returns a literal corresponding to user-specified test case enum.
13486  *
13487  *  @param test_case As per description.
13488  *
13489  *  @return Requested string.
13490  **/
13491 std::string NegativeTest9::getTestCaseString(const _test_case& test_case)
13492 {
13493         std::string result = "?";
13494
13495         switch (test_case)
13496         {
13497         case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT:
13498                 result = "TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT";
13499                 break;
13500         case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT:
13501                 result = "TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT";
13502                 break;
13503         case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON:
13504                 result = "TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON";
13505                 break;
13506         default:
13507                 break;
13508         }
13509
13510         return result;
13511 }
13512
13513 /** Retrieves vertex shader body for user-specified test case.
13514  *
13515  *  @param test_case As per description.
13516  *
13517  *  @return Requested string.
13518  **/
13519 std::string NegativeTest9::getVertexShader(const _test_case& test_case)
13520 {
13521         std::stringstream result_sstream;
13522
13523         /* Form pre-amble */
13524         result_sstream << "#version 400\n"
13525                                           "\n"
13526                                           "#extension GL_ARB_shader_subroutine : require\n"
13527                                           "\n"
13528                                           /* Define a subroutine */
13529                                           "subroutine void subroutineType(inout vec4 test);\n"
13530                                           "\n"
13531                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13532                                           "{\n"
13533                                           "    test += vec4(0, 1, 2, 3);\n"
13534                                           "}\n"
13535                                           "\n"
13536                                           "subroutine uniform subroutineType function;\n"
13537                                           "\n";
13538
13539         /* Include case-specific implementation */
13540         switch (test_case)
13541         {
13542         case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT:
13543         {
13544                 result_sstream << "void main()\n"
13545                                                   "{\n"
13546                                                   "    function = 1.0f;\n"
13547                                                   "\n"
13548                                                   "    function(gl_Position);\n"
13549                                                   "}\n";
13550
13551                 break;
13552         }
13553
13554         case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT:
13555         {
13556                 result_sstream << "void main()\n"
13557                                                   "{\n"
13558                                                   "    function = 1;\n"
13559                                                   "\n"
13560                                                   "    function(gl_Position);\n"
13561                                                   "}\n";
13562
13563                 break;
13564         }
13565
13566         case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON:
13567         {
13568                 result_sstream << "subroutine uniform subroutineType function2;\n"
13569                                                   "\n"
13570                                                   "void main()\n"
13571                                                   "{\n"
13572                                                   "    if (function == function2)\n"
13573                                                   "    {\n"
13574                                                   "        function(gl_Position);\n"
13575                                                   "    }\n"
13576                                                   "    else\n"
13577                                                   "    {\n"
13578                                                   "        function2(gl_Position);\n"
13579                                                   "    }\n"
13580                                                   "}\n";
13581
13582                 break;
13583         }
13584
13585         default:
13586                 break;
13587         } /* switch (test_case) */
13588
13589         /* Done */
13590         return result_sstream.str();
13591 }
13592
13593 /** Executes test iteration.
13594  *
13595  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
13596  */
13597 tcu::TestNode::IterateResult NegativeTest9::iterate()
13598 {
13599         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
13600
13601         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
13602         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
13603         {
13604                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
13605         }
13606
13607         /* Iterate over all test cases */
13608         for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case)
13609         {
13610                 /* Try to build a program object using invalid vertex shader, specific to the
13611                  * iteration we're currently in */
13612                 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case));
13613
13614                 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "",   /* tc_body */
13615                                                                                                   "",                            /* te_body */
13616                                                                                                   "",                            /* gs_body */
13617                                                                                                   "",                            /* fs_body */
13618                                                                                                   DE_NULL,                       /* xfb_varyings */
13619                                                                                                   0,                             /* n_xfb_varyings */
13620                                                                                                   &m_vs_id, DE_NULL, /* out_tc_id */
13621                                                                                                   DE_NULL,                       /* out_te_id */
13622                                                                                                   DE_NULL,                       /* out_gs_id */
13623                                                                                                   DE_NULL,                       /* out_fs_id */
13624                                                                                                   &m_po_id))
13625                 {
13626                         m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for ["
13627                                                            << getTestCaseString(static_cast<_test_case>(test_case))
13628                                                            << "] test case, even though it was invalid." << tcu::TestLog::EndMessage;
13629
13630                         m_has_test_passed = false;
13631                 }
13632
13633                 /* Delete any objects that may have been created */
13634                 deinit();
13635         } /* for (all test cases) */
13636
13637         /** All done */
13638         if (m_has_test_passed)
13639         {
13640                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
13641         }
13642         else
13643         {
13644                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
13645         }
13646
13647         return STOP;
13648 }
13649
13650 /** Constructor.
13651  *
13652  *  @param context Rendering context.
13653  **/
13654 NegativeTest10::NegativeTest10(deqp::Context& context)
13655         : TestCase(context, "function_overloading_forbidden_for_subroutines",
13656                            "Check that an overloaded function cannot be declared with subroutine and "
13657                            "a program will fail to compile or link if any shader or stage contains"
13658                            " two or more  functions with the same name if the name is associated with"
13659                            " a subroutine type.")
13660         , m_has_test_passed(true)
13661         , m_fs_id(0)
13662         , m_gs_id(0)
13663         , m_po_id(0)
13664         , m_tc_id(0)
13665         , m_te_id(0)
13666         , m_vs_id(0)
13667 {
13668         /* Left blank intentionally */
13669 }
13670
13671 /** Deinitializes any GL objects that may have been created during
13672  *  test execution.
13673  **/
13674 void NegativeTest10::deinit()
13675 {
13676         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
13677
13678         if (m_fs_id != 0)
13679         {
13680                 gl.deleteShader(m_fs_id);
13681
13682                 m_fs_id = 0;
13683         }
13684
13685         if (m_gs_id != 0)
13686         {
13687                 gl.deleteShader(m_gs_id);
13688
13689                 m_gs_id = 0;
13690         }
13691
13692         if (m_po_id != 0)
13693         {
13694                 gl.deleteProgram(m_po_id);
13695
13696                 m_po_id = 0;
13697         }
13698
13699         if (m_tc_id != 0)
13700         {
13701                 gl.deleteShader(m_tc_id);
13702
13703                 m_tc_id = 0;
13704         }
13705
13706         if (m_te_id != 0)
13707         {
13708                 gl.deleteShader(m_te_id);
13709
13710                 m_te_id = 0;
13711         }
13712
13713         if (m_vs_id != 0)
13714         {
13715                 gl.deleteShader(m_vs_id);
13716
13717                 m_vs_id = 0;
13718         }
13719 }
13720
13721 /** Retrieves fragment shader that should be used for the purpose of the test.
13722  *  An overloaded version of a subroutine function is inserted if
13723  *  @param include_duplicate_function flag is set to true.
13724  *
13725  *  @param include_duplicate_function As per description.
13726  *
13727  *  @return Requested string.
13728  **/
13729 std::string NegativeTest10::getFragmentShader(bool include_duplicate_function)
13730 {
13731         std::stringstream result_sstream;
13732
13733         result_sstream << "#version 400\n"
13734                                           "\n"
13735                                           "#extension GL_ARB_shader_subroutine : require\n"
13736                                           "\n"
13737                                           "subroutine void subroutineType(inout vec4 test);\n"
13738                                           "\n"
13739                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13740                                           "{\n"
13741                                           "    test = vec4(2, 3, 4, 5);\n"
13742                                           "}\n"
13743                                           "\n"
13744                                           "subroutine uniform subroutineType function;\n"
13745                                           "out vec4 result;\n"
13746                                           "\n";
13747
13748         if (include_duplicate_function)
13749         {
13750                 result_sstream << "void test_function(inout vec4 test)\n"
13751                                                   "{\n"
13752                                                   "    test = vec4(3, 4, 5, 6);\n"
13753                                                   "}\n"
13754                                                   "\n";
13755         }
13756
13757         result_sstream << "void main()\n"
13758                                           "{\n"
13759                                           "    test_function(result);\n"
13760                                           "}\n";
13761
13762         return result_sstream.str();
13763 }
13764
13765 /** Retrieves geometry shader that should be used for the purpose of the test.
13766  *  An overloaded version of a subroutine function is inserted if
13767  *  @param include_duplicate_function flag is set to true.
13768  *
13769  *  @param include_duplicate_function As per description.
13770  *
13771  *  @return Requested string.
13772  **/
13773 std::string NegativeTest10::getGeometryShader(bool include_duplicate_function)
13774 {
13775         std::stringstream result_sstream;
13776
13777         result_sstream << "#version 400\n"
13778                                           "\n"
13779                                           "#extension GL_ARB_shader_subroutine : require\n"
13780                                           "\n"
13781                                           "layout (triangles)                        in;\n"
13782                                           "layout (triangle_strip, max_vertices = 4) out;\n"
13783                                           "\n"
13784                                           "subroutine void subroutineType(inout vec4 test);\n"
13785                                           "\n"
13786                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13787                                           "{\n"
13788                                           "    test = vec4(2, 3, 4, 5);\n"
13789                                           "}\n"
13790                                           "\n"
13791                                           "subroutine uniform subroutineType function;\n"
13792                                           "\n";
13793
13794         if (include_duplicate_function)
13795         {
13796                 result_sstream << "void test_function(inout vec4 test)\n"
13797                                                   "{\n"
13798                                                   "    test = vec4(3, 4, 5, 6);\n"
13799                                                   "}\n"
13800                                                   "\n";
13801         }
13802
13803         result_sstream << "void main()\n"
13804                                           "{\n"
13805                                           "    function(gl_Position);\n"
13806                                           "    EmitVertex();\n"
13807                                           "    EndPrimitive();\n"
13808                                           "}\n";
13809
13810         return result_sstream.str();
13811 }
13812
13813 /** Retrieves tess control shader that should be used for the purpose of the test.
13814  *  An overloaded version of a subroutine function is inserted if
13815  *  @param include_duplicate_function flag is set to true.
13816  *
13817  *  @param include_duplicate_function As per description.
13818  *
13819  *  @return Requested string.
13820  **/
13821 std::string NegativeTest10::getTessellationControlShader(bool include_duplicate_function)
13822 {
13823         std::stringstream result_sstream;
13824
13825         result_sstream << "#version 400\n"
13826                                           "\n"
13827                                           "#extension GL_ARB_shader_subroutine : require\n"
13828                                           "\n"
13829                                           "layout (vertices = 4) out;\n"
13830                                           "\n"
13831                                           "subroutine void subroutineType(inout vec4 test);\n"
13832                                           "\n"
13833                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13834                                           "{\n"
13835                                           "    test = vec4(2, 3, 4, 5);\n"
13836                                           "}\n"
13837                                           "\n"
13838                                           "subroutine uniform subroutineType function;\n"
13839                                           "\n";
13840
13841         if (include_duplicate_function)
13842         {
13843                 result_sstream << "void test_function(inout vec4 test)\n"
13844                                                   "{\n"
13845                                                   "    test = vec4(3, 4, 5, 6);\n"
13846                                                   "}\n"
13847                                                   "\n";
13848         }
13849
13850         result_sstream << "void main()\n"
13851                                           "{\n"
13852                                           "    vec4 temp;\n"
13853                                           "\n"
13854                                           "    function(temp);\n"
13855                                           "\n"
13856                                           "    gl_out[gl_InvocationID].gl_Position = temp;\n"
13857                                           "    gl_TessLevelInner[0]                = temp.x;\n"
13858                                           "    gl_TessLevelInner[1]                = temp.y;\n"
13859                                           "    gl_TessLevelOuter[0]                = temp.z;\n"
13860                                           "    gl_TessLevelOuter[1]                = temp.w;\n"
13861                                           "    gl_TessLevelOuter[2]                = temp.x;\n"
13862                                           "    gl_TessLevelOuter[3]                = temp.y;\n"
13863                                           "}\n";
13864
13865         return result_sstream.str();
13866 }
13867
13868 /** Retrieves tess evaluation shader that should be used for the purpose of the test.
13869  *  An overloaded version of a subroutine function is inserted if
13870  *  @param include_duplicate_function flag is set to true.
13871  *
13872  *  @param include_duplicate_function As per description.
13873  *
13874  *  @return Requested string.
13875  **/
13876 std::string NegativeTest10::getTessellationEvaluationShader(bool include_duplicate_function)
13877 {
13878         std::stringstream result_sstream;
13879
13880         result_sstream << "#version 400\n"
13881                                           "\n"
13882                                           "#extension GL_ARB_shader_subroutine : require\n"
13883                                           "\n"
13884                                           "layout (quads) in;\n"
13885                                           "\n"
13886                                           "subroutine void subroutineType(inout vec4 test);\n"
13887                                           "\n"
13888                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13889                                           "{\n"
13890                                           "    test = vec4(2, 3, 4, 5);\n"
13891                                           "}\n"
13892                                           "\n"
13893                                           "subroutine uniform subroutineType function;\n"
13894                                           "\n";
13895
13896         if (include_duplicate_function)
13897         {
13898                 result_sstream << "void test_function(inout vec4 test)\n"
13899                                                   "{\n"
13900                                                   "    test = vec4(3, 4, 5, 6);\n"
13901                                                   "}\n"
13902                                                   "\n";
13903         }
13904
13905         result_sstream << "void main()\n"
13906                                           "{\n"
13907                                           "    vec4 temp;\n"
13908                                           "\n"
13909                                           "    function(temp);\n"
13910                                           "\n"
13911                                           "    gl_Position = temp;\n"
13912                                           "}\n";
13913
13914         return result_sstream.str();
13915 }
13916
13917 /** Retrieves vertex shader that should be used for the purpose of the test.
13918  *  An overloaded version of a subroutine function is inserted if
13919  *  @param include_duplicate_function flag is set to true.
13920  *
13921  *  @param include_duplicate_function As per description.
13922  *
13923  *  @return Requested string.
13924  **/
13925 std::string NegativeTest10::getVertexShader(bool include_duplicate_function)
13926 {
13927         std::stringstream result_sstream;
13928
13929         result_sstream << "#version 400\n"
13930                                           "\n"
13931                                           "#extension GL_ARB_shader_subroutine : require\n"
13932                                           "\n"
13933                                           "subroutine void subroutineType(inout vec4 test);\n"
13934                                           "\n"
13935                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
13936                                           "{\n"
13937                                           "    test = vec4(2, 3, 4, 5);\n"
13938                                           "}\n"
13939                                           "\n"
13940                                           "subroutine uniform subroutineType function;\n"
13941                                           "\n";
13942
13943         if (include_duplicate_function)
13944         {
13945                 result_sstream << "void test_function(inout vec4 test)\n"
13946                                                   "{\n"
13947                                                   "    test = vec4(3, 4, 5, 6);\n"
13948                                                   "}\n"
13949                                                   "\n";
13950         }
13951
13952         result_sstream << "void main()\n"
13953                                           "{\n"
13954                                           "    function(gl_Position);\n"
13955                                           "}\n";
13956
13957         return result_sstream.str();
13958 }
13959
13960 /** Fills m_test_cases field with test case descriptors */
13961 void NegativeTest10::initTestCases()
13962 {
13963         /* For each test case, only one shader stage should define a function that
13964          * has already been defined as a subroutine. */
13965         for (int offending_shader_stage_it = static_cast<int>(Utils::SHADER_STAGE_FIRST);
13966                  offending_shader_stage_it != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++offending_shader_stage_it)
13967         {
13968                 Utils::_shader_stage offending_shader_stage = static_cast<Utils::_shader_stage>(offending_shader_stage_it);
13969                 /* Form the test case descriptor */
13970                 std::stringstream name_sstream;
13971                 _test_case                test_case;
13972
13973                 name_sstream << "Broken shader stage:" << Utils::getShaderStageString(offending_shader_stage);
13974
13975                 test_case.fs_body = getFragmentShader(offending_shader_stage == Utils::SHADER_STAGE_FRAGMENT);
13976                 test_case.gs_body = getGeometryShader(offending_shader_stage == Utils::SHADER_STAGE_GEOMETRY);
13977                 test_case.name  = name_sstream.str();
13978                 test_case.tc_body =
13979                         getTessellationControlShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL);
13980                 test_case.te_body =
13981                         getTessellationEvaluationShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION);
13982                 test_case.vs_body = getVertexShader(offending_shader_stage == Utils::SHADER_STAGE_VERTEX);
13983
13984                 m_test_cases.push_back(test_case);
13985         }
13986 }
13987
13988 /** Executes test iteration.
13989  *
13990  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
13991  */
13992 tcu::TestNode::IterateResult NegativeTest10::iterate()
13993 {
13994         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
13995
13996         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
13997         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
13998         {
13999                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
14000         }
14001
14002         /* Form test cases */
14003         initTestCases();
14004
14005         /* Iterate over all test cases */
14006         for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end();
14007                  ++test_case_iterator)
14008         {
14009                 const _test_case& test_case = *test_case_iterator;
14010
14011                 /* Try to build the program object */
14012                 if (ShaderSubroutine::Utils::buildProgram(gl, test_case.vs_body, test_case.tc_body, test_case.te_body,
14013                                                                                                   test_case.gs_body, test_case.fs_body, DE_NULL, /* xfb_varyings */
14014                                                                                                   0,                                                                                     /* n_xfb_varyings */
14015                                                                                                   &m_vs_id, (test_case.tc_body.length() > 0) ? &m_tc_id : DE_NULL,
14016                                                                                                   (test_case.te_body.length() > 0) ? &m_te_id : DE_NULL,
14017                                                                                                   (test_case.gs_body.length() > 0) ? &m_gs_id : DE_NULL,
14018                                                                                                   (test_case.fs_body.length() > 0) ? &m_fs_id : DE_NULL, &m_po_id))
14019                 {
14020                         m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for ["
14021                                                            << test_case.name << "] test case, even though it was invalid."
14022                                                            << tcu::TestLog::EndMessage;
14023
14024                         m_has_test_passed = false;
14025                 }
14026
14027                 /* Delete any objects that may have been created */
14028                 deinit();
14029         } /* for (all test cases) */
14030
14031         /** All done */
14032         if (m_has_test_passed)
14033         {
14034                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
14035         }
14036         else
14037         {
14038                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
14039         }
14040
14041         return STOP;
14042 }
14043
14044 /** Constructor.
14045  *
14046  *  @param context Rendering context.
14047  **/
14048 NegativeTest11::NegativeTest11(deqp::Context& context)
14049         : TestCase(context, "subroutine_uniforms_used_for_sampling_atomic_image_functions",
14050                            "Tries to use subroutine uniforms in invalid way in sampling, "
14051                            "atomic and image functions. Verifies that compile- or link-time "
14052                            "error occurs.")
14053         , m_has_test_passed(true)
14054         , m_po_id(0)
14055         , m_vs_id(0)
14056 {
14057         /* Left blank intentionally */
14058 }
14059
14060 /** Deinitializes any GL objects that may have been created during
14061  *  test execution.
14062  **/
14063 void NegativeTest11::deinit()
14064 {
14065         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
14066
14067         if (m_po_id != 0)
14068         {
14069                 gl.deleteProgram(m_po_id);
14070
14071                 m_po_id = 0;
14072         }
14073
14074         if (m_vs_id != 0)
14075         {
14076                 gl.deleteShader(m_vs_id);
14077
14078                 m_vs_id = 0;
14079         }
14080 }
14081
14082 /** Returns a literal corresponding to user-specified test case enum.
14083  *
14084  *  @param test_case As per description.
14085  *
14086  *  @return Requested string.
14087  **/
14088 std::string NegativeTest11::getTestCaseString(const _test_case& test_case)
14089 {
14090         std::string result = "?";
14091
14092         switch (test_case)
14093         {
14094         case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT:
14095                 result = "TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT";
14096                 break;
14097         case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT:
14098                 result = "TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT";
14099                 break;
14100         case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT:
14101                 result = "TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT";
14102                 break;
14103         default:
14104                 break;
14105         }
14106
14107         return result;
14108 }
14109
14110 /** Retrieves vertex shader body for user-specified test case.
14111  *
14112  *  @param test_case As per description.
14113  *
14114  *  @return Requested string.
14115  **/
14116 std::string NegativeTest11::getVertexShader(const _test_case& test_case)
14117 {
14118         std::stringstream result_sstream;
14119
14120         /* Form pre-amble */
14121         result_sstream << "#version 400\n"
14122                                           "\n"
14123                                           "#extension GL_ARB_shader_subroutine : require\n";
14124
14125         if (test_case == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT)
14126         {
14127                 result_sstream << "#extension GL_ARB_shader_atomic_counters : require\n";
14128         }
14129
14130         result_sstream << "\n"
14131                                           /* Define a subroutine */
14132                                           "subroutine void subroutineType(inout vec4 test);\n"
14133                                           "\n"
14134                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
14135                                           "{\n"
14136                                           "    test += vec4(0, 1, 2, 3);\n"
14137                                           "}\n"
14138                                           "\n"
14139                                           "subroutine uniform subroutineType function;\n"
14140                                           "\n"
14141
14142                                           /* Define main() body */
14143                                           "void main()\n"
14144                                           "{\n";
14145
14146         /* Implement case-specific behavior */
14147         switch (test_case)
14148         {
14149         case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT:
14150         {
14151                 result_sstream << "if (atomicCounter(function) > 2)\n"
14152                                                   "{\n"
14153                                                   "    gl_Position = vec4(1);\n"
14154                                                   "}\n";
14155
14156                 break;
14157         }
14158
14159         case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT:
14160         {
14161                 result_sstream << "imageStore(function, vec2(0.0, 1.0), vec4(1.0) );\n";
14162
14163                 break;
14164         }
14165
14166         case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT:
14167         {
14168                 result_sstream << "gl_Position = texture(function, vec2(1.0) );\n";
14169
14170                 break;
14171         }
14172
14173         default:
14174                 break;
14175         } /* switch (test_case) */
14176
14177         /* Close main() body */
14178         result_sstream << "}\n";
14179
14180         /* Done */
14181         return result_sstream.str();
14182 }
14183
14184 /** Executes test iteration.
14185  *
14186  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
14187  */
14188 tcu::TestNode::IterateResult NegativeTest11::iterate()
14189 {
14190         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
14191
14192         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
14193         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
14194         {
14195                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
14196         }
14197
14198         /* Iterate over all test cases */
14199         for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case)
14200         {
14201                 if (static_cast<_test_case>(test_case) == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT &&
14202                         !m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters"))
14203                 {
14204                         /* This iteration requires atomic counter support that this GL implementation
14205                          * is not capable of. Skip the iteration
14206                          */
14207                         continue;
14208                 }
14209
14210                 /* Try to build a program object using invalid vertex shader, specific to the
14211                  * iteration we're currently in */
14212                 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case));
14213
14214                 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "",   /* tc_body */
14215                                                                                                   "",                            /* te_body */
14216                                                                                                   "",                            /* gs_body */
14217                                                                                                   "",                            /* fs_body */
14218                                                                                                   DE_NULL,                       /* xfb_varyings */
14219                                                                                                   0,                             /* n_xfb_varyings */
14220                                                                                                   &m_vs_id, DE_NULL, /* out_tc_id */
14221                                                                                                   DE_NULL,                       /* out_te_id */
14222                                                                                                   DE_NULL,                       /* out_gs_id */
14223                                                                                                   DE_NULL,                       /* out_fs_id */
14224                                                                                                   &m_po_id))
14225                 {
14226                         m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for ["
14227                                                            << getTestCaseString(static_cast<_test_case>(test_case))
14228                                                            << "] test case, even though it was invalid." << tcu::TestLog::EndMessage;
14229
14230                         m_has_test_passed = false;
14231                 }
14232
14233                 /* Delete any objects that may have been created */
14234                 deinit();
14235         } /* for (all test cases) */
14236
14237         /** All done */
14238         if (m_has_test_passed)
14239         {
14240                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
14241         }
14242         else
14243         {
14244                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
14245         }
14246
14247         return STOP;
14248 }
14249
14250 /** Constructor.
14251  *
14252  *  @param context Rendering context.
14253  **/
14254 NegativeTest12::NegativeTest12(deqp::Context& context)
14255         : TestCase(context, "subroutines_not_allowed_as_variables_constructors_and_argument_or_return_types",
14256                            "Verifies that it is not allowed to use subroutine type for "
14257                            "local/global variables, constructors or argument/return type.")
14258         , m_has_test_passed(true)
14259         , m_po_id(0)
14260         , m_vs_id(0)
14261 {
14262         /* Left blank intentionally */
14263 }
14264
14265 /** Deinitializes any GL objects that may have been created during
14266  *  test execution.
14267  **/
14268 void NegativeTest12::deinit()
14269 {
14270         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
14271
14272         if (m_po_id != 0)
14273         {
14274                 gl.deleteProgram(m_po_id);
14275
14276                 m_po_id = 0;
14277         }
14278
14279         if (m_vs_id != 0)
14280         {
14281                 gl.deleteShader(m_vs_id);
14282
14283                 m_vs_id = 0;
14284         }
14285 }
14286
14287 /** Returns a literal corresponding to user-specified test case enum.
14288  *
14289  *  @param test_case As per description.
14290  *
14291  *  @return Requested string.
14292  **/
14293 std::string NegativeTest12::getTestCaseString(const _test_case& test_case)
14294 {
14295         std::string result = "?";
14296
14297         switch (test_case)
14298         {
14299         case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE:
14300                 result = "TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE";
14301                 break;
14302         case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE:
14303                 result = "TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE";
14304                 break;
14305         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR:
14306                 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR";
14307                 break;
14308         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT:
14309                 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT";
14310                 break;
14311         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE:
14312                 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE";
14313                 break;
14314         default:
14315                 break;
14316         }
14317
14318         return result;
14319 }
14320
14321 /** Retrieves vertex shader body for user-specified test case.
14322  *
14323  *  @param test_case As per description.
14324  *
14325  *  @return Requested string.
14326  **/
14327 std::string NegativeTest12::getVertexShader(const _test_case& test_case)
14328 {
14329         std::stringstream result_sstream;
14330
14331         /* Form pre-amble */
14332         result_sstream << "#version 400\n"
14333                                           "\n"
14334                                           "#extension GL_ARB_shader_subroutine : require\n"
14335                                           "\n"
14336                                           /* Define a subroutine */
14337                                           "subroutine void subroutineType(inout vec4 test);\n"
14338                                           "\n"
14339                                           "subroutine(subroutineType) void test_function(inout vec4 test)\n"
14340                                           "{\n"
14341                                           "    test += vec4(0, 1, 2, 3);\n"
14342                                           "}\n"
14343                                           "\n"
14344                                           "subroutine uniform subroutineType function;\n"
14345                                           "\n";
14346
14347         /* Include case-specific implementation */
14348         switch (test_case)
14349         {
14350         case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE:
14351         {
14352                 result_sstream << "void main()\n"
14353                                                   "{\n"
14354                                                   "    subroutine subroutineType function2;\n"
14355                                                   "    vec4                      result;\n"
14356                                                   "\n"
14357                                                   "    function2(result);\n"
14358                                                   "    gl_Position = result;\n"
14359                                                   "}\n";
14360
14361                 break;
14362         }
14363
14364         case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE:
14365         {
14366                 result_sstream << "subroutine subroutineType function2;\n"
14367                                                   "\n"
14368                                                   "void main()\n"
14369                                                   "{\n"
14370                                                   "    vec4 result;\n"
14371                                                   "\n"
14372                                                   "    function2(result);\n"
14373                                                   "    gl_Position = result;\n"
14374                                                   "}\n";
14375
14376                 break;
14377         }
14378
14379         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR:
14380         {
14381                 result_sstream << "void main()\n"
14382                                                   "{\n"
14383                                                   "    subroutineType(function);\n"
14384                                                   "}\n";
14385
14386                 break;
14387         }
14388
14389         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT:
14390         {
14391                 result_sstream << "vec4 test_function(subroutineType argument)\n"
14392                                                   "{\n"
14393                                                   "    vec4 result = vec4(1, 2, 3, 4);\n"
14394                                                   "\n"
14395                                                   "    argument(result);\n"
14396                                                   "\n"
14397                                                   "    return result;\n"
14398                                                   "}\n"
14399                                                   "\n"
14400                                                   "void main()\n"
14401                                                   "{\n"
14402                                                   "    test_function(function);\n"
14403                                                   "}\n";
14404
14405                 break;
14406         }
14407
14408         case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE:
14409         {
14410                 result_sstream << "subroutineType test_function()\n"
14411                                                   "{\n"
14412                                                   "    return function;\n"
14413                                                   "}\n"
14414                                                   "\n"
14415                                                   "void main()\n"
14416                                                   "{\n"
14417                                                   "    test_function()(gl_Position);\n"
14418                                                   "}\n";
14419
14420                 break;
14421         }
14422
14423         default:
14424                 break;
14425         } /* switch (test_case) */
14426
14427         /* Done */
14428         return result_sstream.str();
14429 }
14430
14431 /** Executes test iteration.
14432  *
14433  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
14434  */
14435 tcu::TestNode::IterateResult NegativeTest12::iterate()
14436 {
14437         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
14438
14439         /* Do not execute the test if GL_ARB_shader_subroutine is not supported */
14440         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine"))
14441         {
14442                 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported.");
14443         }
14444
14445         /* Iterate over all test cases */
14446         for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case)
14447         {
14448                 /* Try to build a program object using invalid vertex shader, specific to the
14449                  * iteration we're currently in */
14450                 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case));
14451
14452                 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "",   /* tc_body */
14453                                                                                                   "",                            /* te_body */
14454                                                                                                   "",                            /* gs_body */
14455                                                                                                   "",                            /* fs_body */
14456                                                                                                   DE_NULL,                       /* xfb_varyings */
14457                                                                                                   0,                             /* n_xfb_varyings */
14458                                                                                                   &m_vs_id, DE_NULL, /* out_tc_id */
14459                                                                                                   DE_NULL,                       /* out_te_id */
14460                                                                                                   DE_NULL,                       /* out_gs_id */
14461                                                                                                   DE_NULL,                       /* out_fs_id */
14462                                                                                                   &m_po_id))
14463                 {
14464                         m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for ["
14465                                                            << getTestCaseString(static_cast<_test_case>(test_case))
14466                                                            << "] test case, even though it was invalid." << tcu::TestLog::EndMessage;
14467
14468                         m_has_test_passed = false;
14469                 }
14470
14471                 /* Delete any objects that may have been created */
14472                 deinit();
14473         } /* for (all test cases) */
14474
14475         /** All done */
14476         if (m_has_test_passed)
14477         {
14478                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
14479         }
14480         else
14481         {
14482                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
14483         }
14484
14485         return STOP;
14486 }
14487
14488 } /* ShaderSubroutine */
14489
14490 /** Constructor.
14491  *
14492  *  @param context Rendering context.
14493  **/
14494 ShaderSubroutineTests::ShaderSubroutineTests(deqp::Context& context)
14495         : TestCaseGroup(context, "shader_subroutine", "Verifies \"shader_subroutine\" functionality")
14496 {
14497         /* Left blank on purpose */
14498 }
14499
14500 /** Initializes a texture_storage_multisample test group.
14501  *
14502  **/
14503 void ShaderSubroutineTests::init(void)
14504 {
14505         addChild(new ShaderSubroutine::APITest1(m_context));
14506         addChild(new ShaderSubroutine::APITest2(m_context));
14507         addChild(new ShaderSubroutine::FunctionalTest1_2(m_context));
14508         addChild(new ShaderSubroutine::FunctionalTest3_4(m_context));
14509         addChild(new ShaderSubroutine::FunctionalTest5(m_context));
14510         addChild(new ShaderSubroutine::FunctionalTest6(m_context));
14511         addChild(new ShaderSubroutine::FunctionalTest7_8(m_context));
14512         addChild(new ShaderSubroutine::FunctionalTest9(m_context));
14513         addChild(new ShaderSubroutine::FunctionalTest10(m_context));
14514         addChild(new ShaderSubroutine::FunctionalTest11(m_context));
14515         addChild(new ShaderSubroutine::FunctionalTest12(m_context));
14516         addChild(new ShaderSubroutine::FunctionalTest13(m_context));
14517         addChild(new ShaderSubroutine::FunctionalTest14_15(m_context));
14518         addChild(new ShaderSubroutine::FunctionalTest16(m_context));
14519         addChild(new ShaderSubroutine::FunctionalTest17(m_context));
14520         addChild(new ShaderSubroutine::FunctionalTest18_19(m_context));
14521         addChild(new ShaderSubroutine::FunctionalTest20_21(m_context));
14522         addChild(new ShaderSubroutine::NegativeTest1(m_context));
14523         addChild(new ShaderSubroutine::NegativeTest2(m_context));
14524         addChild(new ShaderSubroutine::NegativeTest3(m_context));
14525         addChild(new ShaderSubroutine::NegativeTest4(m_context));
14526         addChild(new ShaderSubroutine::NegativeTest5(m_context));
14527         addChild(new ShaderSubroutine::NegativeTest6(m_context));
14528         addChild(new ShaderSubroutine::NegativeTest7(m_context));
14529         addChild(new ShaderSubroutine::NegativeTest8(m_context));
14530         addChild(new ShaderSubroutine::NegativeTest9(m_context));
14531         addChild(new ShaderSubroutine::NegativeTest10(m_context));
14532         addChild(new ShaderSubroutine::NegativeTest11(m_context));
14533         addChild(new ShaderSubroutine::NegativeTest12(m_context));
14534 }
14535
14536 } /* glcts namespace */