modules/gles3/functional/es3fNegativeShaderApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Negative Shader API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fNegativeShaderApiTests.hpp"
  25 #include "es3fApiCase.hpp"
  26 #include "gluShaderProgram.hpp"
  27 #include "gluContextInfo.hpp"
  28 #include "deUniquePtr.hpp"
  29
  30 #include "glwDefs.hpp"
  31 #include "glwEnums.hpp"
  32
  33 using namespace glw; // GL types
  34
  35 namespace deqp
  36 {
  37 namespace gles3
  38 {
  39 namespace Functional
  40 {
  41
  42 using tcu::TestLog;
  43
  44 static const char* vertexShaderSource           =       "#version 300 es\n"
  45                                                                                                 "void main (void)\n"
  46                                                                                                 "{\n"
  47                                                                                                 "       gl_Position = vec4(0.0);\n"
  48                                                                                                 "}\n\0";
  49
  50 static const char* fragmentShaderSource         =       "#version 300 es\n"
  51                                                                                                 "layout(location = 0) out mediump vec4 fragColor;"
  52                                                                                                 "void main (void)\n"
  53                                                                                                 "{\n"
  54                                                                                                 "       fragColor = vec4(0.0);\n"
  55                                                                                                 "}\n\0";
  56
  57 static const char* uniformTestVertSource        =       "#version 300 es\n"
  58                                                                                                 "uniform mediump vec4 vec4_v;\n"
  59                                                                                                 "uniform mediump mat4 mat4_v;\n"
  60                                                                                                 "void main (void)\n"
  61                                                                                                 "{\n"
  62                                                                                                 "       gl_Position = mat4_v * vec4_v;\n"
  63                                                                                                 "}\n\0";
  64
  65 static const char* uniformTestFragSource        =       "#version 300 es\n"
  66                                                                                                 "uniform mediump ivec4 ivec4_f;\n"
  67                                                                                                 "uniform mediump uvec4 uvec4_f;\n"
  68                                                                                                 "uniform sampler2D sampler_f;\n"
  69                                                                                                 "layout(location = 0) out mediump vec4 fragColor;"
  70                                                                                                 "void main (void)\n"
  71                                                                                                 "{\n"
  72                                                                                                 "       fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n"
  73                                                                                                 "       fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n"
  74                                                                                                 "}\n\0";
  75
  76 static const char* uniformBlockVertSource       =       "#version 300 es\n"
  77                                                                                                 "layout(shared) uniform Block { lowp float var; };\n"
  78                                                                                                 "void main (void)\n"
  79                                                                                                 "{\n"
  80                                                                                                 "       gl_Position = vec4(var);\n"
  81                                                                                                 "}\n\0";
  82
  83 NegativeShaderApiTests::NegativeShaderApiTests (Context& context)
  84         : TestCaseGroup(context, "shader", "Negative Shader API Cases")
  85 {
  86 }
  87
  88 NegativeShaderApiTests::~NegativeShaderApiTests (void)
  89 {
  90 }
  91
  92 void NegativeShaderApiTests::init (void)
  93 {
  94         // Shader control commands
  95
  96         ES3F_ADD_API_CASE(create_shader, "Invalid glCreateShader() usage",
  97                 {
  98                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
  99                         glCreateShader(-1);
 100                         expectError(GL_INVALID_ENUM);
 101                         m_log << TestLog::EndSection;
 102                 });
 103         ES3F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage",
 104                 {
 105                         // \note Shader compilation must be supported.
 106
 107                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 108                         glShaderSource(1, 0, 0, 0);
 109                         expectError(GL_INVALID_VALUE);
 110                         m_log << TestLog::EndSection;
 111
 112                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if count is less than 0.");
 113                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 114                         glShaderSource(shader, -1, 0, 0);
 115                         expectError(GL_INVALID_VALUE);
 116                         m_log << TestLog::EndSection;
 117
 118                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 119                         GLuint program = glCreateProgram();
 120                         glShaderSource(program, 0, 0, 0);
 121                         expectError(GL_INVALID_OPERATION);
 122                         m_log << TestLog::EndSection;
 123
 124                         glDeleteProgram(program);
 125                         glDeleteShader(shader);
 126                 });
 127         ES3F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage",
 128                 {
 129                         // \note Shader compilation must be supported.
 130
 131                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 132                         glCompileShader(9);
 133                         expectError(GL_INVALID_VALUE);
 134                         m_log << TestLog::EndSection;
 135
 136                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 137                         GLuint program = glCreateProgram();
 138                         glCompileShader(program);
 139                         expectError(GL_INVALID_OPERATION);
 140                         m_log << TestLog::EndSection;
 141
 142                         glDeleteProgram(program);
 143                 });
 144         ES3F_ADD_API_CASE(delete_shader, "Invalid glDeleteShader() usage",
 145                 {
 146                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 147                         glDeleteShader(9);
 148                         expectError(GL_INVALID_VALUE);
 149                         m_log << TestLog::EndSection;
 150                 });
 151         ES3F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage",
 152                 {
 153                         std::vector<deInt32> binaryFormats;
 154                         getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
 155                         deBool shaderBinarySupported = !binaryFormats.empty();
 156                         if (!shaderBinarySupported)
 157                                 m_log << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
 158                         else
 159                                 m_log << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
 160
 161                         GLuint shaders[2];
 162                         shaders[0]              = glCreateShader(GL_VERTEX_SHADER);
 163                         shaders[1]              = glCreateShader(GL_VERTEX_SHADER);
 164
 165                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryFormat is not an accepted value.");
 166                         glShaderBinary(1, &shaders[0], -1, 0, 0);
 167                         expectError(GL_INVALID_ENUM);
 168                         m_log << TestLog::EndSection;
 169
 170                         if (shaderBinarySupported)
 171                         {
 172                                 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if the data pointed to by binary does not match the format specified by binaryFormat.");
 173                                 const GLbyte data = 0x005F;
 174                                 glShaderBinary(1, &shaders[0], binaryFormats[0], &data, 1);
 175                                 expectError(GL_INVALID_VALUE);
 176                                 m_log << TestLog::EndSection;
 177
 178                                 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if more than one of the handles in shaders refers to the same type of shader, or GL_INVALID_VALUE due to invalid data pointer.");
 179                                 glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0);
 180                                 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
 181                                 m_log << TestLog::EndSection;
 182                         }
 183
 184                         glDeleteShader(shaders[0]);
 185                         glDeleteShader(shaders[1]);
 186                 });
 187         ES3F_ADD_API_CASE(attach_shader, "Invalid glAttachShader() usage",
 188                 {
 189                         GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
 190                         GLuint shader2 = glCreateShader(GL_VERTEX_SHADER);
 191                         GLuint program = glCreateProgram();
 192
 193                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 194                         glAttachShader(shader1, shader1);
 195                         expectError(GL_INVALID_OPERATION);
 196                         m_log << TestLog::EndSection;
 197
 198                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 199                         glAttachShader(program, program);
 200                         expectError(GL_INVALID_OPERATION);
 201                         glAttachShader(shader1, program);
 202                         expectError(GL_INVALID_OPERATION);
 203                         m_log << TestLog::EndSection;
 204
 205                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
 206                         glAttachShader(program, -1);
 207                         expectError(GL_INVALID_VALUE);
 208                         glAttachShader(-1, shader1);
 209                         expectError(GL_INVALID_VALUE);
 210                         glAttachShader(-1, -1);
 211                         expectError(GL_INVALID_VALUE);
 212                         m_log << TestLog::EndSection;
 213
 214                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is already attached to program.");
 215                         glAttachShader(program, shader1);
 216                         expectError(GL_NO_ERROR);
 217                         glAttachShader(program, shader1);
 218                         expectError(GL_INVALID_OPERATION);
 219                         m_log << TestLog::EndSection;
 220
 221                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader of the same type as shader is already attached to program.");
 222                         glAttachShader(program, shader2);
 223                         expectError(GL_INVALID_OPERATION);
 224                         m_log << TestLog::EndSection;
 225
 226                         glDeleteProgram(program);
 227                         glDeleteShader(shader1);
 228                         glDeleteShader(shader2);
 229                 });
 230         ES3F_ADD_API_CASE(detach_shader, "Invalid glDetachShader() usage",
 231                 {
 232                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 233                         GLuint program = glCreateProgram();
 234
 235                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
 236                         glDetachShader(-1, shader);
 237                         expectError(GL_INVALID_VALUE);
 238                         glDetachShader(program, -1);
 239                         expectError(GL_INVALID_VALUE);
 240                         glDetachShader(-1, -1);
 241                         expectError(GL_INVALID_VALUE);
 242                         m_log << TestLog::EndSection;
 243
 244                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 245                         glDetachShader(shader, shader);
 246                         expectError(GL_INVALID_OPERATION);
 247                         m_log << TestLog::EndSection;
 248
 249                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 250                         glDetachShader(program, program);
 251                         expectError(GL_INVALID_OPERATION);
 252                         glDetachShader(shader, program);
 253                         expectError(GL_INVALID_OPERATION);
 254                         m_log << TestLog::EndSection;
 255
 256                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not attached to program.");
 257                         glDetachShader(program, shader);
 258                         expectError(GL_INVALID_OPERATION);
 259                         m_log << TestLog::EndSection;
 260
 261                         glDeleteProgram(program);
 262                         glDeleteShader(shader);
 263                 });
 264         ES3F_ADD_API_CASE(link_program, "Invalid glLinkProgram() usage",
 265                 {
 266                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 267
 268                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 269                         glLinkProgram(-1);
 270                         expectError(GL_INVALID_VALUE);
 271                         m_log << TestLog::EndSection;
 272
 273                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 274                         glLinkProgram(shader);
 275                         expectError(GL_INVALID_OPERATION);
 276                         m_log << TestLog::EndSection;
 277
 278                         glDeleteShader(shader);
 279
 280                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is the currently active program object and transform feedback mode is active.");
 281                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 282                         deUint32                                        buf;
 283                         deUint32                                        tfID;
 284                         const char* tfVarying           = "gl_Position";
 285
 286                         glGenTransformFeedbacks         (1, &tfID);
 287                         glGenBuffers                            (1, &buf);
 288
 289                         glUseProgram                            (program.getProgram());
 290                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
 291                         glLinkProgram                           (program.getProgram());
 292                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
 293                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
 294                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
 295                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
 296                         glBeginTransformFeedback        (GL_TRIANGLES);
 297                         expectError                                     (GL_NO_ERROR);
 298
 299                         glLinkProgram                           (program.getProgram());
 300                         expectError                                     (GL_INVALID_OPERATION);
 301
 302                         glEndTransformFeedback          ();
 303                         glDeleteTransformFeedbacks      (1, &tfID);
 304                         glDeleteBuffers                         (1, &buf);
 305                         expectError                                     (GL_NO_ERROR);
 306                         m_log << TestLog::EndSection;
 307                 });
 308         ES3F_ADD_API_CASE(use_program, "Invalid glUseProgram() usage",
 309                 {
 310                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 311
 312                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
 313                         glUseProgram(-1);
 314                         expectError(GL_INVALID_VALUE);
 315                         m_log << TestLog::EndSection;
 316
 317                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 318                         glUseProgram(shader);
 319                         expectError(GL_INVALID_OPERATION);
 320                         m_log << TestLog::EndSection;
 321
 322                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback mode is active and not paused.");
 323                         glu::ShaderProgram                      program1(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 324                         glu::ShaderProgram                      program2(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 325                         deUint32                                        buf;
 326                         deUint32                                        tfID;
 327                         const char* tfVarying           = "gl_Position";
 328
 329                         glGenTransformFeedbacks         (1, &tfID);
 330                         glGenBuffers                            (1, &buf);
 331
 332                         glUseProgram                            (program1.getProgram());
 333                         glTransformFeedbackVaryings     (program1.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
 334                         glLinkProgram                           (program1.getProgram());
 335                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
 336                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
 337                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
 338                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
 339                         glBeginTransformFeedback        (GL_TRIANGLES);
 340                         expectError                                     (GL_NO_ERROR);
 341
 342                         glUseProgram                            (program2.getProgram());
 343                         expectError                                     (GL_INVALID_OPERATION);
 344
 345                         glPauseTransformFeedback        ();
 346                         glUseProgram                            (program2.getProgram());
 347                         expectError                                     (GL_NO_ERROR);
 348
 349                         glEndTransformFeedback          ();
 350                         glDeleteTransformFeedbacks      (1, &tfID);
 351                         glDeleteBuffers                         (1, &buf);
 352                         expectError                                     (GL_NO_ERROR);
 353                         m_log << TestLog::EndSection;
 354
 355                         glUseProgram(0);
 356                         glDeleteShader(shader);
 357                 });
 358         ES3F_ADD_API_CASE(delete_program, "Invalid glDeleteProgram() usage",
 359                 {
 360                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 361                         glDeleteProgram(-1);
 362                         expectError(GL_INVALID_VALUE);
 363                         m_log << TestLog::EndSection;
 364                 });
 365         ES3F_ADD_API_CASE(validate_program, "Invalid glValidateProgram() usage",
 366                 {
 367                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 368
 369                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 370                         glValidateProgram(-1);
 371                         expectError(GL_INVALID_VALUE);
 372                         m_log << TestLog::EndSection;
 373
 374                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 375                         glValidateProgram(shader);
 376                         expectError(GL_INVALID_OPERATION);
 377                         m_log << TestLog::EndSection;
 378
 379                         glDeleteShader(shader);
 380                 });
 381         ES3F_ADD_API_CASE(get_program_binary, "Invalid glGetProgramBinary() usage",
 382                 {
 383                         glu::ShaderProgram                              program                 (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 384                         glu::ShaderProgram                              programInvalid  (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
 385                         GLenum                                                  binaryFormat    = -1;
 386                         GLsizei                                                 binaryLength    = -1;
 387                         GLint                                                   binaryPtr               = -1;
 388                         GLint                                                   bufSize                 = -1;
 389                         GLint                                                   linkStatus              = -1;
 390
 391                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if bufSize is less than the size of GL_PROGRAM_BINARY_LENGTH for program.");
 392                         glGetProgramiv          (program.getProgram(), GL_PROGRAM_BINARY_LENGTH,        &bufSize);
 393                         expectError                     (GL_NO_ERROR);
 394                         glGetProgramiv          (program.getProgram(), GL_LINK_STATUS,                          &linkStatus);
 395                         m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
 396                         m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
 397                         expectError                     (GL_NO_ERROR);
 398
 399                         glGetProgramBinary      (program.getProgram(), 0, &binaryLength, &binaryFormat, &binaryPtr);
 400                         expectError                     (GL_INVALID_OPERATION);
 401                         if (bufSize > 0)
 402                         {
 403                                 glGetProgramBinary      (program.getProgram(), bufSize-1, &binaryLength, &binaryFormat, &binaryPtr);
 404                                 expectError                     (GL_INVALID_OPERATION);
 405                         }
 406                         m_log << TestLog::EndSection;
 407
 408                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_LINK_STATUS for the program object is false.");
 409                         glGetProgramiv          (programInvalid.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
 410                         expectError                     (GL_NO_ERROR);
 411                         glGetProgramiv          (programInvalid.getProgram(), GL_LINK_STATUS,                   &linkStatus);
 412                         m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
 413                         m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
 414                         expectError                     (GL_NO_ERROR);
 415
 416                         glGetProgramBinary      (programInvalid.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryPtr);
 417                         expectError                     (GL_INVALID_OPERATION);
 418                         m_log << TestLog::EndSection;
 419                 });
 420         ES3F_ADD_API_CASE(program_binary, "Invalid glProgramBinary() usage",
 421                 {
 422                         glu::ShaderProgram              srcProgram              (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 423                         GLuint                                  dstProgram              = glCreateProgram();
 424                         GLuint                                  dummyShader             = glCreateShader(GL_VERTEX_SHADER);
 425                         GLenum                                  binaryFormat    = -1;
 426                         GLsizei                                 binaryLength    = -1;
 427                         std::vector<deUint8>    binaryBuf;
 428                         GLint                                   bufSize                 = -1;
 429                         GLint                                   linkStatus              = -1;
 430
 431                         glGetProgramiv          (srcProgram.getProgram(), GL_PROGRAM_BINARY_LENGTH,     &bufSize);
 432                         glGetProgramiv          (srcProgram.getProgram(), GL_LINK_STATUS,                       &linkStatus);
 433                         m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
 434                         m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
 435
 436                         TCU_CHECK(bufSize >= 0);
 437
 438                         if (bufSize > 0)
 439                         {
 440                                 binaryBuf.resize(bufSize);
 441                                 glGetProgramBinary      (srcProgram.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryBuf[0]);
 442                                 expectError                     (GL_NO_ERROR);
 443
 444                                 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not the name of an existing program object.");
 445                                 glProgramBinary         (dummyShader, binaryFormat, &binaryBuf[0], binaryLength);
 446                                 expectError                     (GL_INVALID_OPERATION);
 447                                 m_log << TestLog::EndSection;
 448
 449                                 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryFormat is not a value recognized by the implementation.");
 450                                 glProgramBinary         (dstProgram, -1, &binaryBuf[0], binaryLength);
 451                                 expectError                     (GL_INVALID_ENUM);
 452                                 m_log << TestLog::EndSection;
 453                         }
 454
 455                         glDeleteShader(dummyShader);
 456                         glDeleteProgram(dstProgram);
 457                 });
 458         ES3F_ADD_API_CASE(program_parameteri, "Invalid glProgramParameteri() usage",
 459                 {
 460                         GLuint  program = glCreateProgram();
 461
 462                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of an existing program object.");
 463                         glProgramParameteri             (0, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
 464                         expectError                             (GL_INVALID_VALUE);
 465                         m_log << TestLog::EndSection;
 466
 467                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT.");
 468                         glProgramParameteri             (program, -1, GL_TRUE);
 469                         expectError                             (GL_INVALID_ENUM);
 470                         m_log << TestLog::EndSection;
 471
 472                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE.");
 473                         glProgramParameteri             (program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
 474                         expectError                             (GL_INVALID_VALUE);
 475                         m_log << TestLog::EndSection;
 476
 477                         glDeleteProgram(program);
 478                 });
 479         ES3F_ADD_API_CASE(gen_samplers, "Invalid glGenSamplers() usage",
 480                 {
 481                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
 482                         GLuint sampler;
 483                         glGenSamplers   (-1, &sampler);
 484                         expectError             (GL_INVALID_VALUE);
 485                         m_log << TestLog::EndSection;
 486                 });
 487         ES3F_ADD_API_CASE(bind_sampler, "Invalid glBindSampler() usage",
 488                 {
 489                         int                             maxTexImageUnits;
 490                         GLuint                  sampler;
 491                         glGetIntegerv   (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits);
 492                         glGenSamplers   (1, &sampler);
 493
 494                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if unit is greater than or equal to the value of GL_MAX_COMBIED_TEXTURE_IMAGE_UNITS.");
 495                         glBindSampler   (maxTexImageUnits, sampler);
 496                         expectError             (GL_INVALID_VALUE);
 497                         m_log << TestLog::EndSection;
 498
 499                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not zero or a name previously returned from a call to glGenSamplers.");
 500                         glBindSampler   (1, -1);
 501                         expectError             (GL_INVALID_OPERATION);
 502                         m_log << TestLog::EndSection;
 503
 504                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler has been deleted by a call to glDeleteSamplers.");
 505                         glDeleteSamplers(1, &sampler);
 506                         glBindSampler   (1, sampler);
 507                         expectError             (GL_INVALID_OPERATION);
 508                         m_log << TestLog::EndSection;
 509                 });
 510         ES3F_ADD_API_CASE(delete_samplers, "Invalid glDeleteSamplers() usage",
 511                 {
 512                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
 513                         glDeleteSamplers(-1, 0);
 514                         expectError             (GL_INVALID_VALUE);
 515                         m_log << TestLog::EndSection;
 516                 });
 517         ES3F_ADD_API_CASE(get_sampler_parameteriv, "Invalid glGetSamplerParameteriv() usage",
 518                 {
 519                         int                             params  = -1;
 520                         GLuint                  sampler;
 521                         glGenSamplers   (1, &sampler);
 522
 523                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to glGenSamplers.");
 524                         glGetSamplerParameteriv (-1, GL_TEXTURE_MAG_FILTER, &params);
 525                         expectError                             (GL_INVALID_OPERATION);
 526                         m_log << TestLog::EndSection;
 527
 528                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 529                         glGetSamplerParameteriv (sampler, -1, &params);
 530                         expectError                             (GL_INVALID_ENUM);
 531                         m_log << TestLog::EndSection;
 532
 533                         glDeleteSamplers(1, &sampler);
 534                 });
 535         ES3F_ADD_API_CASE(get_sampler_parameterfv, "Invalid glGetSamplerParameterfv() usage",
 536                 {
 537                         float                   params  = 0.0f;
 538                         GLuint                  sampler;
 539                         glGenSamplers   (1, &sampler);
 540
 541                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to glGenSamplers.");
 542                         glGetSamplerParameterfv (-1, GL_TEXTURE_MAG_FILTER, &params);
 543                         expectError                             (GL_INVALID_OPERATION);
 544                         m_log << TestLog::EndSection;
 545
 546                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 547                         glGetSamplerParameterfv (sampler, -1, &params);
 548                         expectError                             (GL_INVALID_ENUM);
 549                         m_log << TestLog::EndSection;
 550
 551                         glDeleteSamplers(1, &sampler);
 552                 });
 553         ES3F_ADD_API_CASE(sampler_parameteri, "Invalid glSamplerParameteri() usage",
 554                 {
 555                         GLuint                  sampler;
 556                         glGenSamplers   (1, &sampler);
 557
 558                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
 559                         glSamplerParameteri             (-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 560                         expectError                             (GL_INVALID_OPERATION);
 561                         m_log << TestLog::EndSection;
 562
 563                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
 564                         glSamplerParameteri             (sampler, GL_TEXTURE_WRAP_S, -1);
 565                         expectError                             (GL_INVALID_ENUM);
 566                         m_log << TestLog::EndSection;
 567
 568                         glDeleteSamplers(1, &sampler);
 569                 });
 570         ES3F_ADD_API_CASE(sampler_parameteriv, "Invalid glSamplerParameteriv() usage",
 571                 {
 572                         int                             params  = -1;
 573                         GLuint                  sampler;
 574                         glGenSamplers   (1, &sampler);
 575
 576                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
 577                         params = GL_CLAMP_TO_EDGE;
 578                         glSamplerParameteriv    (-1, GL_TEXTURE_WRAP_S, &params);
 579                         expectError                             (GL_INVALID_OPERATION);
 580                         m_log << TestLog::EndSection;
 581
 582                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
 583                         params = -1;
 584                         glSamplerParameteriv    (sampler, GL_TEXTURE_WRAP_S, &params);
 585                         expectError                             (GL_INVALID_ENUM);
 586                         m_log << TestLog::EndSection;
 587
 588                         glDeleteSamplers(1, &sampler);
 589                 });
 590         ES3F_ADD_API_CASE(sampler_parameterf, "Invalid glSamplerParameterf() usage",
 591                 {
 592                         GLuint                  sampler;
 593                         glGenSamplers   (1, &sampler);
 594
 595                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
 596                         glSamplerParameterf             (-1, GL_TEXTURE_MIN_LOD, -1000.0f);
 597                         expectError                             (GL_INVALID_OPERATION);
 598                         m_log << TestLog::EndSection;
 599
 600                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
 601                         glSamplerParameterf             (sampler, GL_TEXTURE_WRAP_S, -1.0f);
 602                         expectError                             (GL_INVALID_ENUM);
 603                         m_log << TestLog::EndSection;
 604
 605                         glDeleteSamplers(1, &sampler);
 606                 });
 607         ES3F_ADD_API_CASE(sampler_parameterfv, "Invalid glSamplerParameterfv() usage",
 608                 {
 609                         float                   params  = 0.0f;
 610                         GLuint                  sampler;
 611                         glGenSamplers   (1, &sampler);
 612
 613                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
 614                         params = -1000.0f;
 615                         glSamplerParameterfv    (-1, GL_TEXTURE_WRAP_S, &params);
 616                         expectError                             (GL_INVALID_OPERATION);
 617                         m_log << TestLog::EndSection;
 618
 619                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
 620                         params = -1.0f;
 621                         glSamplerParameterfv    (sampler, GL_TEXTURE_WRAP_S, &params);
 622                         expectError                             (GL_INVALID_ENUM);
 623                         m_log << TestLog::EndSection;
 624
 625                         glDeleteSamplers(1, &sampler);
 626                 });
 627
 628         // Shader data commands
 629
 630         ES3F_ADD_API_CASE(get_attrib_location, "Invalid glGetAttribLocation() usage",
 631                 {
 632                         GLuint programEmpty             = glCreateProgram();
 633                         GLuint shader                   = glCreateShader(GL_VERTEX_SHADER);
 634
 635                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 636
 637                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 638                         glBindAttribLocation    (programEmpty, 0, "test");
 639                         glGetAttribLocation             (programEmpty, "test");
 640                         expectError                             (GL_INVALID_OPERATION);
 641                         m_log << TestLog::EndSection;
 642
 643                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a program or shader object.");
 644                         glUseProgram                    (program.getProgram());
 645                         glBindAttribLocation    (program.getProgram(), 0, "test");
 646                         expectError                             (GL_NO_ERROR);
 647                         glGetAttribLocation             (program.getProgram(), "test");
 648                         expectError                             (GL_NO_ERROR);
 649                         glGetAttribLocation             (-2, "test");
 650                         expectError                             (GL_INVALID_VALUE);
 651                         m_log << TestLog::EndSection;
 652
 653                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 654                         glGetAttribLocation             (shader, "test");
 655                         expectError                             (GL_INVALID_OPERATION);
 656                         m_log << TestLog::EndSection;
 657
 658                         glUseProgram                    (0);
 659                         glDeleteShader                  (shader);
 660                         glDeleteProgram                 (programEmpty);
 661                 });
 662         ES3F_ADD_API_CASE(get_uniform_location, "Invalid glGetUniformLocation() usage",
 663                 {
 664                         GLuint programEmpty = glCreateProgram();
 665                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 666
 667                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 668
 669                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 670                         glGetUniformLocation(programEmpty, "test");
 671                         expectError(GL_INVALID_OPERATION);
 672                         m_log << TestLog::EndSection;
 673
 674                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 675                         glUseProgram(program.getProgram());
 676                         glGetUniformLocation(-2, "test");
 677                         expectError(GL_INVALID_VALUE);
 678                         m_log << TestLog::EndSection;
 679
 680                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 681                         glGetAttribLocation(shader, "test");
 682                         expectError(GL_INVALID_OPERATION);
 683                         m_log << TestLog::EndSection;
 684
 685                         glUseProgram(0);
 686                         glDeleteProgram(programEmpty);
 687                         glDeleteShader(shader);
 688                 });
 689         ES3F_ADD_API_CASE(bind_attrib_location, "Invalid glBindAttribLocation() usage",
 690                 {
 691                         GLuint program = glCreateProgram();
 692                         GLuint maxIndex = m_context.getContextInfo().getInt(GL_MAX_VERTEX_ATTRIBS);
 693                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 694
 695                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 696                         glBindAttribLocation(program, maxIndex, "test");
 697                         expectError(GL_INVALID_VALUE);
 698                         m_log << TestLog::EndSection;
 699
 700                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
 701                         glBindAttribLocation(program, maxIndex-1, "gl_test");
 702                         expectError(GL_INVALID_OPERATION);
 703                         m_log << TestLog::EndSection;
 704
 705                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 706                         glBindAttribLocation(-1, maxIndex-1, "test");
 707                         expectError(GL_INVALID_VALUE);
 708                         m_log << TestLog::EndSection;
 709
 710                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 711                         glBindAttribLocation(shader, maxIndex-1, "test");
 712                         expectError(GL_INVALID_OPERATION);
 713                         m_log << TestLog::EndSection;
 714
 715                         glDeleteProgram(program);
 716                         glDeleteShader(shader);
 717                 });
 718         ES3F_ADD_API_CASE(uniform_block_binding, "Invalid glUniformBlockBinding() usage",
 719                 {
 720                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
 721
 722                         glUseProgram    (program.getProgram());
 723
 724                         GLint                   maxUniformBufferBindings;
 725                         GLint                   numActiveUniforms                       = -1;
 726                         GLint                   numActiveBlocks                         = -1;
 727                         glGetIntegerv   (GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
 728                         glGetProgramiv  (program.getProgram(), GL_ACTIVE_UNIFORMS,                      &numActiveUniforms);
 729                         glGetProgramiv  (program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS,        &numActiveBlocks);
 730                         m_log << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings << TestLog::EndMessage;
 731                         m_log << TestLog::Message << "// GL_ACTIVE_UNIFORMS = "                         << numActiveUniforms            << TestLog::EndMessage;
 732                         m_log << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = "           << numActiveBlocks                      << TestLog::EndMessage;
 733                         expectError             (GL_NO_ERROR);
 734
 735                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program.");
 736                         glUniformBlockBinding(program.getProgram(), -1, 0);
 737                         expectError(GL_INVALID_VALUE);
 738                         glUniformBlockBinding(program.getProgram(), 5, 0);
 739                         expectError(GL_INVALID_VALUE);
 740                         m_log << tcu::TestLog::EndSection;
 741
 742                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if uniformBlockBinding is greater than or equal to the value of GL_MAX_UNIFORM_BUFFER_BINDINGS.");
 743                         glUniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0);
 744                         expectError(GL_INVALID_VALUE);
 745                         m_log << tcu::TestLog::EndSection;
 746
 747                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object generated by the GL.");
 748                         glUniformBlockBinding(-1, 0, 0);
 749                         expectError(GL_INVALID_VALUE);
 750                         m_log << tcu::TestLog::EndSection;
 751                 });
 752
 753         // glUniform*f
 754
 755         ES3F_ADD_API_CASE(uniformf_invalid_program, "Invalid glUniform{1234}f() usage",
 756                 {
 757                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 758                         glUseProgram(0);
 759                         glUniform1f(-1, 0.0f);
 760                         expectError(GL_INVALID_OPERATION);
 761                         glUniform2f(-1, 0.0f, 0.0f);
 762                         expectError(GL_INVALID_OPERATION);
 763                         glUniform3f(-1, 0.0f, 0.0f, 0.0f);
 764                         expectError(GL_INVALID_OPERATION);
 765                         glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
 766                         expectError(GL_INVALID_OPERATION);
 767                         m_log << tcu::TestLog::EndSection;
 768                 });
 769         ES3F_ADD_API_CASE(uniformf_incompatible_type, "Invalid glUniform{1234}f() usage",
 770                 {
 771                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 772
 773                         glUseProgram(program.getProgram());
 774                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
 775                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
 776                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
 777                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
 778                         expectError(GL_NO_ERROR);
 779
 780                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
 781                         {
 782                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 783                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 784                         }
 785
 786                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
 787                         glUseProgram(program.getProgram());
 788                         glUniform1f(vec4_v, 0.0f);
 789                         expectError(GL_INVALID_OPERATION);
 790                         glUniform2f(vec4_v, 0.0f, 0.0f);
 791                         expectError(GL_INVALID_OPERATION);
 792                         glUniform3f(vec4_v, 0.0f, 0.0f, 0.0f);
 793                         expectError(GL_INVALID_OPERATION);
 794                         glUniform4f(vec4_v, 0.0f, 0.0f, 0.0f, 0.0f);
 795                         expectError(GL_NO_ERROR);
 796                         m_log << tcu::TestLog::EndSection;
 797
 798                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}f is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
 799                         glUseProgram(program.getProgram());
 800                         glUniform4f(ivec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
 801                         expectError(GL_INVALID_OPERATION);
 802                         glUniform4f(uvec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
 803                         expectError(GL_INVALID_OPERATION);
 804                         m_log << tcu::TestLog::EndSection;
 805
 806                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
 807                         glUseProgram(program.getProgram());
 808                         glUniform1f(sampler_f, 0.0f);
 809                         expectError(GL_INVALID_OPERATION);
 810                         m_log << tcu::TestLog::EndSection;
 811
 812                         glUseProgram(0);
 813                 });
 814         ES3F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage",
 815                 {
 816                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 817
 818                         glUseProgram(program.getProgram());
 819                         expectError(GL_NO_ERROR);
 820
 821                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
 822                         glUseProgram(program.getProgram());
 823                         glUniform1f(-2, 0.0f);
 824                         expectError(GL_INVALID_OPERATION);
 825                         glUniform2f(-2, 0.0f, 0.0f);
 826                         expectError(GL_INVALID_OPERATION);
 827                         glUniform3f(-2, 0.0f, 0.0f, 0.0f);
 828                         expectError(GL_INVALID_OPERATION);
 829                         glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
 830                         expectError(GL_INVALID_OPERATION);
 831
 832                         glUseProgram(program.getProgram());
 833                         glUniform1f(-1, 0.0f);
 834                         expectError(GL_NO_ERROR);
 835                         glUniform2f(-1, 0.0f, 0.0f);
 836                         expectError(GL_NO_ERROR);
 837                         glUniform3f(-1, 0.0f, 0.0f, 0.0f);
 838                         expectError(GL_NO_ERROR);
 839                         glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
 840                         expectError(GL_NO_ERROR);
 841                         m_log << tcu::TestLog::EndSection;
 842
 843                         glUseProgram(0);
 844                 });
 845
 846         // glUniform*fv
 847
 848         ES3F_ADD_API_CASE(uniformfv_invalid_program, "Invalid glUniform{1234}fv() usage",
 849                 {
 850                         std::vector<GLfloat> data(4);
 851
 852                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 853                         glUseProgram(0);
 854                         glUniform1fv(-1, 1, &data[0]);
 855                         expectError(GL_INVALID_OPERATION);
 856                         glUniform2fv(-1, 1, &data[0]);
 857                         expectError(GL_INVALID_OPERATION);
 858                         glUniform3fv(-1, 1, &data[0]);
 859                         expectError(GL_INVALID_OPERATION);
 860                         glUniform4fv(-1, 1, &data[0]);
 861                         expectError(GL_INVALID_OPERATION);
 862                         m_log << tcu::TestLog::EndSection;
 863                 });
 864         ES3F_ADD_API_CASE(uniformfv_incompatible_type, "Invalid glUniform{1234}fv() usage",
 865                 {
 866                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 867
 868                         glUseProgram(program.getProgram());
 869                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
 870                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
 871                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
 872                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
 873                         expectError(GL_NO_ERROR);
 874
 875                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
 876                         {
 877                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 878                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 879                         }
 880
 881                         std::vector<GLfloat> data(4);
 882
 883                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
 884                         glUseProgram(program.getProgram());
 885                         glUniform1fv(vec4_v, 1, &data[0]);
 886                         expectError(GL_INVALID_OPERATION);
 887                         glUniform2fv(vec4_v, 1, &data[0]);
 888                         expectError(GL_INVALID_OPERATION);
 889                         glUniform3fv(vec4_v, 1, &data[0]);
 890                         expectError(GL_INVALID_OPERATION);
 891                         glUniform4fv(vec4_v, 1, &data[0]);
 892                         expectError(GL_NO_ERROR);
 893                         m_log << tcu::TestLog::EndSection;
 894
 895                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}fv is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
 896                         glUseProgram(program.getProgram());
 897                         glUniform4fv(ivec4_f, 1, &data[0]);
 898                         expectError(GL_INVALID_OPERATION);
 899                         glUniform4fv(uvec4_f, 1, &data[0]);
 900                         expectError(GL_INVALID_OPERATION);
 901                         m_log << tcu::TestLog::EndSection;
 902
 903                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
 904                         glUseProgram(program.getProgram());
 905                         glUniform1fv(sampler_f, 1, &data[0]);
 906                         expectError(GL_INVALID_OPERATION);
 907                         m_log << tcu::TestLog::EndSection;
 908
 909                         glUseProgram(0);
 910                 });
 911         ES3F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage",
 912                 {
 913                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 914
 915                         glUseProgram(program.getProgram());
 916                         expectError(GL_NO_ERROR);
 917
 918                         std::vector<GLfloat> data(4);
 919
 920                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
 921                         glUseProgram(program.getProgram());
 922                         glUniform1fv(-2, 1, &data[0]);
 923                         expectError(GL_INVALID_OPERATION);
 924                         glUniform2fv(-2, 1, &data[0]);
 925                         expectError(GL_INVALID_OPERATION);
 926                         glUniform3fv(-2, 1, &data[0]);
 927                         expectError(GL_INVALID_OPERATION);
 928                         glUniform4fv(-2, 1, &data[0]);
 929                         expectError(GL_INVALID_OPERATION);
 930
 931                         glUseProgram(program.getProgram());
 932                         glUniform1fv(-1, 1, &data[0]);
 933                         expectError(GL_NO_ERROR);
 934                         glUniform2fv(-1, 1, &data[0]);
 935                         expectError(GL_NO_ERROR);
 936                         glUniform3fv(-1, 1, &data[0]);
 937                         expectError(GL_NO_ERROR);
 938                         glUniform4fv(-1, 1, &data[0]);
 939                         expectError(GL_NO_ERROR);
 940                         m_log << tcu::TestLog::EndSection;
 941
 942                         glUseProgram(0);
 943                 });
 944         ES3F_ADD_API_CASE(uniformfv_invalid_count, "Invalid glUniform{1234}fv() usage",
 945                 {
 946                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 947
 948                         glUseProgram                    (program.getProgram());
 949                         GLint vec4_v                    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
 950                         expectError(GL_NO_ERROR);
 951
 952                         if (vec4_v == -1)
 953                         {
 954                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 955                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 956                         }
 957
 958                         std::vector<GLfloat> data(8);
 959
 960                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
 961                         glUseProgram(program.getProgram());
 962                         glUniform1fv(vec4_v, 2, &data[0]);
 963                         expectError(GL_INVALID_OPERATION);
 964                         glUniform2fv(vec4_v, 2, &data[0]);
 965                         expectError(GL_INVALID_OPERATION);
 966                         glUniform3fv(vec4_v, 2, &data[0]);
 967                         expectError(GL_INVALID_OPERATION);
 968                         glUniform4fv(vec4_v, 2, &data[0]);
 969                         expectError(GL_INVALID_OPERATION);
 970                         m_log << tcu::TestLog::EndSection;
 971
 972                         glUseProgram(0);
 973                 });
 974
 975         // glUniform*i
 976
 977         ES3F_ADD_API_CASE(uniformi_invalid_program, "Invalid glUniform{1234}i() usage",
 978                 {
 979                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 980                         glUseProgram(0);
 981                         glUniform1i(-1, 0);
 982                         expectError(GL_INVALID_OPERATION);
 983                         glUniform2i(-1, 0, 0);
 984                         expectError(GL_INVALID_OPERATION);
 985                         glUniform3i(-1, 0, 0, 0);
 986                         expectError(GL_INVALID_OPERATION);
 987                         glUniform4i(-1, 0, 0, 0, 0);
 988                         expectError(GL_INVALID_OPERATION);
 989                         m_log << tcu::TestLog::EndSection;
 990                 });
 991         ES3F_ADD_API_CASE(uniformi_incompatible_type, "Invalid glUniform{1234}i() usage",
 992                 {
 993                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 994
 995                         glUseProgram(program.getProgram());
 996                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
 997                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
 998                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
 999                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
1000                         expectError(GL_NO_ERROR);
1001
1002                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1003                         {
1004                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1005                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1006                         }
1007
1008                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1009                         glUseProgram(program.getProgram());
1010                         glUniform1i(ivec4_f, 0);
1011                         expectError(GL_INVALID_OPERATION);
1012                         glUniform2i(ivec4_f, 0, 0);
1013                         expectError(GL_INVALID_OPERATION);
1014                         glUniform3i(ivec4_f, 0, 0, 0);
1015                         expectError(GL_INVALID_OPERATION);
1016                         glUniform4i(ivec4_f, 0, 0, 0, 0);
1017                         expectError(GL_NO_ERROR);
1018                         m_log << tcu::TestLog::EndSection;
1019
1020                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type unsigned int, uvec2, uvec3, uvec4, or an array of these.");
1021                         glUseProgram(program.getProgram());
1022                         glUniform1i(uvec4_f, 0);
1023                         expectError(GL_INVALID_OPERATION);
1024                         glUniform2i(uvec4_f, 0, 0);
1025                         expectError(GL_INVALID_OPERATION);
1026                         glUniform3i(uvec4_f, 0, 0, 0);
1027                         expectError(GL_INVALID_OPERATION);
1028                         glUniform4i(uvec4_f, 0, 0, 0, 0);
1029                         expectError(GL_INVALID_OPERATION);
1030                         m_log << tcu::TestLog::EndSection;
1031
1032                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1033                         glUseProgram(program.getProgram());
1034                         glUniform1i(vec4_v, 0);
1035                         expectError(GL_INVALID_OPERATION);
1036                         glUniform2i(vec4_v, 0, 0);
1037                         expectError(GL_INVALID_OPERATION);
1038                         glUniform3i(vec4_v, 0, 0, 0);
1039                         expectError(GL_INVALID_OPERATION);
1040                         glUniform4i(vec4_v, 0, 0, 0, 0);
1041                         expectError(GL_INVALID_OPERATION);
1042                         m_log << tcu::TestLog::EndSection;
1043
1044                         glUseProgram(0);
1045                 });
1046         ES3F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage",
1047                 {
1048                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1049
1050                         glUseProgram(program.getProgram());
1051                         expectError(GL_NO_ERROR);
1052
1053                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1054                         glUseProgram(program.getProgram());
1055                         glUniform1i(-2, 0);
1056                         expectError(GL_INVALID_OPERATION);
1057                         glUniform2i(-2, 0, 0);
1058                         expectError(GL_INVALID_OPERATION);
1059                         glUniform3i(-2, 0, 0, 0);
1060                         expectError(GL_INVALID_OPERATION);
1061                         glUniform4i(-2, 0, 0, 0, 0);
1062                         expectError(GL_INVALID_OPERATION);
1063
1064                         glUseProgram(program.getProgram());
1065                         glUniform1i(-1, 0);
1066                         expectError(GL_NO_ERROR);
1067                         glUniform2i(-1, 0, 0);
1068                         expectError(GL_NO_ERROR);
1069                         glUniform3i(-1, 0, 0, 0);
1070                         expectError(GL_NO_ERROR);
1071                         glUniform4i(-1, 0, 0, 0, 0);
1072                         expectError(GL_NO_ERROR);
1073                         m_log << tcu::TestLog::EndSection;
1074
1075                         glUseProgram(0);
1076                 });
1077
1078         // glUniform*iv
1079
1080         ES3F_ADD_API_CASE(uniformiv_invalid_program, "Invalid glUniform{1234}iv() usage",
1081                 {
1082                         std::vector<GLint> data(4);
1083
1084                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1085                         glUseProgram(0);
1086                         glUniform1iv(-1, 1, &data[0]);
1087                         expectError(GL_INVALID_OPERATION);
1088                         glUniform2iv(-1, 1, &data[0]);
1089                         expectError(GL_INVALID_OPERATION);
1090                         glUniform3iv(-1, 1, &data[0]);
1091                         expectError(GL_INVALID_OPERATION);
1092                         glUniform4iv(-1, 1, &data[0]);
1093                         expectError(GL_INVALID_OPERATION);
1094                         m_log << tcu::TestLog::EndSection;
1095                 });
1096         ES3F_ADD_API_CASE(uniformiv_incompatible_type, "Invalid glUniform{1234}iv() usage",
1097                 {
1098                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1099
1100                         glUseProgram(program.getProgram());
1101                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1102                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
1103                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
1104                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
1105                         expectError(GL_NO_ERROR);
1106
1107                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1108                         {
1109                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1110                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1111                         }
1112
1113                         std::vector<GLint> data(4);
1114
1115                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1116                         glUseProgram(program.getProgram());
1117                         glUniform1iv(ivec4_f, 1, &data[0]);
1118                         expectError(GL_INVALID_OPERATION);
1119                         glUniform2iv(ivec4_f, 1, &data[0]);
1120                         expectError(GL_INVALID_OPERATION);
1121                         glUniform3iv(ivec4_f, 1, &data[0]);
1122                         expectError(GL_INVALID_OPERATION);
1123                         glUniform4iv(ivec4_f, 1, &data[0]);
1124                         expectError(GL_NO_ERROR);
1125                         m_log << tcu::TestLog::EndSection;
1126
1127                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1128                         glUseProgram(program.getProgram());
1129                         glUniform1iv(vec4_v, 1, &data[0]);
1130                         expectError(GL_INVALID_OPERATION);
1131                         glUniform2iv(vec4_v, 1, &data[0]);
1132                         expectError(GL_INVALID_OPERATION);
1133                         glUniform3iv(vec4_v, 1, &data[0]);
1134                         expectError(GL_INVALID_OPERATION);
1135                         glUniform4iv(vec4_v, 1, &data[0]);
1136                         expectError(GL_INVALID_OPERATION);
1137                         m_log << tcu::TestLog::EndSection;
1138
1139                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type unsigned int, uvec2, uvec3 or uvec4.");
1140                         glUseProgram(program.getProgram());
1141                         glUniform1iv(uvec4_f, 1, &data[0]);
1142                         expectError(GL_INVALID_OPERATION);
1143                         glUniform2iv(uvec4_f, 1, &data[0]);
1144                         expectError(GL_INVALID_OPERATION);
1145                         glUniform3iv(uvec4_f, 1, &data[0]);
1146                         expectError(GL_INVALID_OPERATION);
1147                         glUniform4iv(uvec4_f, 1, &data[0]);
1148                         expectError(GL_INVALID_OPERATION);
1149                         m_log << tcu::TestLog::EndSection;
1150
1151                         glUseProgram(0);
1152                 });
1153         ES3F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage",
1154                 {
1155                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1156
1157                         glUseProgram(program.getProgram());
1158                         expectError(GL_NO_ERROR);
1159
1160                         std::vector<GLint> data(4);
1161
1162                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1163                         glUseProgram(program.getProgram());
1164                         glUniform1iv(-2, 1, &data[0]);
1165                         expectError(GL_INVALID_OPERATION);
1166                         glUniform2iv(-2, 1, &data[0]);
1167                         expectError(GL_INVALID_OPERATION);
1168                         glUniform3iv(-2, 1, &data[0]);
1169                         expectError(GL_INVALID_OPERATION);
1170                         glUniform4iv(-2, 1, &data[0]);
1171                         expectError(GL_INVALID_OPERATION);
1172
1173                         glUseProgram(program.getProgram());
1174                         glUniform1iv(-1, 1, &data[0]);
1175                         expectError(GL_NO_ERROR);
1176                         glUniform2iv(-1, 1, &data[0]);
1177                         expectError(GL_NO_ERROR);
1178                         glUniform3iv(-1, 1, &data[0]);
1179                         expectError(GL_NO_ERROR);
1180                         glUniform4iv(-1, 1, &data[0]);
1181                         expectError(GL_NO_ERROR);
1182                         m_log << tcu::TestLog::EndSection;
1183
1184                         glUseProgram(0);
1185                 });
1186         ES3F_ADD_API_CASE(uniformiv_invalid_count, "Invalid glUniform{1234}iv() usage",
1187                 {
1188                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1189
1190                         glUseProgram                    (program.getProgram());
1191                         GLint ivec4_f                   = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1192                         expectError(GL_NO_ERROR);
1193
1194                         if (ivec4_f == -1)
1195                         {
1196                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1197                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1198                         }
1199
1200                         std::vector<GLint> data(8);
1201
1202                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1203                         glUseProgram(program.getProgram());
1204                         glUniform1iv(ivec4_f, 2, &data[0]);
1205                         expectError(GL_INVALID_OPERATION);
1206                         glUniform2iv(ivec4_f, 2, &data[0]);
1207                         expectError(GL_INVALID_OPERATION);
1208                         glUniform3iv(ivec4_f, 2, &data[0]);
1209                         expectError(GL_INVALID_OPERATION);
1210                         glUniform4iv(ivec4_f, 2, &data[0]);
1211                         expectError(GL_INVALID_OPERATION);
1212                         m_log << tcu::TestLog::EndSection;
1213
1214                         glUseProgram(0);
1215                 });
1216
1217         // glUniform{1234}ui
1218
1219         ES3F_ADD_API_CASE(uniformui_invalid_program, "Invalid glUniform{234}ui() usage",
1220                 {
1221                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1222                         glUseProgram(0);
1223                         glUniform1ui(-1, 0);
1224                         expectError(GL_INVALID_OPERATION);
1225                         glUniform2ui(-1, 0, 0);
1226                         expectError(GL_INVALID_OPERATION);
1227                         glUniform3ui(-1, 0, 0, 0);
1228                         expectError(GL_INVALID_OPERATION);
1229                         glUniform4ui(-1, 0, 0, 0, 0);
1230                         expectError(GL_INVALID_OPERATION);
1231                         m_log << tcu::TestLog::EndSection;
1232                 });
1233         ES3F_ADD_API_CASE(uniformui_incompatible_type, "Invalid glUniform{1234}ui() usage",
1234                 {
1235                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1236
1237                         glUseProgram(program.getProgram());
1238                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1239                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
1240                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
1241                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
1242                         expectError(GL_NO_ERROR);
1243
1244                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1245                         {
1246                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1247                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1248                         }
1249
1250                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1251                         glUseProgram(program.getProgram());
1252                         glUniform1ui(uvec4_f, 0);
1253                         expectError(GL_INVALID_OPERATION);
1254                         glUniform2ui(uvec4_f, 0, 0);
1255                         expectError(GL_INVALID_OPERATION);
1256                         glUniform3ui(uvec4_f, 0, 0, 0);
1257                         expectError(GL_INVALID_OPERATION);
1258                         glUniform4ui(uvec4_f, 0, 0, 0, 0);
1259                         expectError(GL_NO_ERROR);
1260                         m_log << tcu::TestLog::EndSection;
1261
1262                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type int, ivec2, ivec3, ivec4, or an array of these.");
1263                         glUseProgram(program.getProgram());
1264                         glUniform1ui(ivec4_f, 0);
1265                         expectError(GL_INVALID_OPERATION);
1266                         glUniform2ui(ivec4_f, 0, 0);
1267                         expectError(GL_INVALID_OPERATION);
1268                         glUniform3ui(ivec4_f, 0, 0, 0);
1269                         expectError(GL_INVALID_OPERATION);
1270                         glUniform4ui(ivec4_f, 0, 0, 0, 0);
1271                         expectError(GL_INVALID_OPERATION);
1272                         m_log << tcu::TestLog::EndSection;
1273
1274                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1275                         glUseProgram(program.getProgram());
1276                         glUniform1ui(vec4_v, 0);
1277                         expectError(GL_INVALID_OPERATION);
1278                         glUniform2ui(vec4_v, 0, 0);
1279                         expectError(GL_INVALID_OPERATION);
1280                         glUniform3ui(vec4_v, 0, 0, 0);
1281                         expectError(GL_INVALID_OPERATION);
1282                         glUniform4ui(vec4_v, 0, 0, 0, 0);
1283                         expectError(GL_INVALID_OPERATION);
1284                         m_log << tcu::TestLog::EndSection;
1285
1286                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1287                         glUseProgram(program.getProgram());
1288                         glUniform1ui(sampler_f, 0);
1289                         expectError(GL_INVALID_OPERATION);
1290                         m_log << tcu::TestLog::EndSection;
1291
1292                         glUseProgram(0);
1293                 });
1294         ES3F_ADD_API_CASE(uniformui_invalid_location, "Invalid glUniform{1234}ui() usage",
1295                 {
1296                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1297
1298                         glUseProgram(program.getProgram());
1299                         expectError(GL_NO_ERROR);
1300
1301                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1302                         glUseProgram(program.getProgram());
1303                         glUniform1i(-2, 0);
1304                         expectError(GL_INVALID_OPERATION);
1305                         glUniform2i(-2, 0, 0);
1306                         expectError(GL_INVALID_OPERATION);
1307                         glUniform3i(-2, 0, 0, 0);
1308                         expectError(GL_INVALID_OPERATION);
1309                         glUniform4i(-2, 0, 0, 0, 0);
1310                         expectError(GL_INVALID_OPERATION);
1311
1312                         glUseProgram(program.getProgram());
1313                         glUniform1i(-1, 0);
1314                         expectError(GL_NO_ERROR);
1315                         glUniform2i(-1, 0, 0);
1316                         expectError(GL_NO_ERROR);
1317                         glUniform3i(-1, 0, 0, 0);
1318                         expectError(GL_NO_ERROR);
1319                         glUniform4i(-1, 0, 0, 0, 0);
1320                         expectError(GL_NO_ERROR);
1321                         m_log << tcu::TestLog::EndSection;
1322
1323                         glUseProgram(0);
1324                 });
1325
1326         // glUniform{1234}uiv
1327
1328         ES3F_ADD_API_CASE(uniformuiv_invalid_program, "Invalid glUniform{234}uiv() usage",
1329                 {
1330                         std::vector<GLuint> data(4);
1331
1332                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1333                         glUseProgram(0);
1334                         glUniform1uiv(-1, 1, &data[0]);
1335                         expectError(GL_INVALID_OPERATION);
1336                         glUniform2uiv(-1, 1, &data[0]);
1337                         expectError(GL_INVALID_OPERATION);
1338                         glUniform3uiv(-1, 1, &data[0]);
1339                         expectError(GL_INVALID_OPERATION);
1340                         glUniform4uiv(-1, 1, &data[0]);
1341                         expectError(GL_INVALID_OPERATION);
1342                         m_log << tcu::TestLog::EndSection;
1343                 });
1344         ES3F_ADD_API_CASE(uniformuiv_incompatible_type, "Invalid glUniform{1234}uiv() usage",
1345                 {
1346                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1347
1348                         glUseProgram(program.getProgram());
1349                         GLint vec4_v    = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1350                         GLint ivec4_f   = glGetUniformLocation(program.getProgram(), "ivec4_f");        // ivec4
1351                         GLint uvec4_f   = glGetUniformLocation(program.getProgram(), "uvec4_f");        // uvec4
1352                         GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
1353                         expectError(GL_NO_ERROR);
1354
1355                         if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1356                         {
1357                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1358                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1359                         }
1360
1361                         std::vector<GLuint> data(4);
1362
1363                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1364                         glUseProgram(program.getProgram());
1365                         glUniform1uiv(uvec4_f, 1, &data[0]);
1366                         expectError(GL_INVALID_OPERATION);
1367                         glUniform2uiv(uvec4_f, 1, &data[0]);
1368                         expectError(GL_INVALID_OPERATION);
1369                         glUniform3uiv(uvec4_f, 1, &data[0]);
1370                         expectError(GL_INVALID_OPERATION);
1371                         glUniform4uiv(uvec4_f, 1, &data[0]);
1372                         expectError(GL_NO_ERROR);
1373                         m_log << tcu::TestLog::EndSection;
1374
1375                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1376                         glUseProgram(program.getProgram());
1377                         glUniform1uiv(vec4_v, 1, &data[0]);
1378                         expectError(GL_INVALID_OPERATION);
1379                         glUniform2uiv(vec4_v, 1, &data[0]);
1380                         expectError(GL_INVALID_OPERATION);
1381                         glUniform3uiv(vec4_v, 1, &data[0]);
1382                         expectError(GL_INVALID_OPERATION);
1383                         glUniform4uiv(vec4_v, 1, &data[0]);
1384                         expectError(GL_INVALID_OPERATION);
1385                         m_log << tcu::TestLog::EndSection;
1386
1387                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type int, ivec2, ivec3 or ivec4.");
1388                         glUseProgram(program.getProgram());
1389                         glUniform1uiv(ivec4_f, 1, &data[0]);
1390                         expectError(GL_INVALID_OPERATION);
1391                         glUniform2uiv(ivec4_f, 1, &data[0]);
1392                         expectError(GL_INVALID_OPERATION);
1393                         glUniform3uiv(ivec4_f, 1, &data[0]);
1394                         expectError(GL_INVALID_OPERATION);
1395                         glUniform4uiv(ivec4_f, 1, &data[0]);
1396                         expectError(GL_INVALID_OPERATION);
1397                         m_log << tcu::TestLog::EndSection;
1398
1399                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1400                         glUseProgram(program.getProgram());
1401                         glUniform1uiv(sampler_f, 1, &data[0]);
1402                         expectError(GL_INVALID_OPERATION);
1403                         m_log << tcu::TestLog::EndSection;
1404
1405                         glUseProgram(0);
1406                 });
1407         ES3F_ADD_API_CASE(uniformuiv_invalid_location, "Invalid glUniform{1234}uiv() usage",
1408                 {
1409                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1410
1411                         glUseProgram(program.getProgram());
1412                         expectError(GL_NO_ERROR);
1413
1414                         std::vector<GLuint> data(4);
1415
1416                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1417                         glUseProgram(program.getProgram());
1418                         glUniform1uiv(-2, 1, &data[0]);
1419                         expectError(GL_INVALID_OPERATION);
1420                         glUniform2uiv(-2, 1, &data[0]);
1421                         expectError(GL_INVALID_OPERATION);
1422                         glUniform3uiv(-2, 1, &data[0]);
1423                         expectError(GL_INVALID_OPERATION);
1424                         glUniform4uiv(-2, 1, &data[0]);
1425                         expectError(GL_INVALID_OPERATION);
1426
1427                         glUseProgram(program.getProgram());
1428                         glUniform1uiv(-1, 1, &data[0]);
1429                         expectError(GL_NO_ERROR);
1430                         glUniform2uiv(-1, 1, &data[0]);
1431                         expectError(GL_NO_ERROR);
1432                         glUniform3uiv(-1, 1, &data[0]);
1433                         expectError(GL_NO_ERROR);
1434                         glUniform4uiv(-1, 1, &data[0]);
1435                         expectError(GL_NO_ERROR);
1436                         m_log << tcu::TestLog::EndSection;
1437
1438                         glUseProgram(0);
1439                 });
1440         ES3F_ADD_API_CASE(uniformuiv_invalid_count, "Invalid glUniform{1234}uiv() usage",
1441                 {
1442                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1443
1444                         glUseProgram                    (program.getProgram());
1445                         int uvec4_f                             = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1446                         expectError(GL_NO_ERROR);
1447
1448                         if (uvec4_f == -1)
1449                         {
1450                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1451                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1452                         }
1453
1454                         std::vector<GLuint> data(8);
1455
1456                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1457                         glUseProgram(program.getProgram());
1458                         glUniform1uiv(uvec4_f, 2, &data[0]);
1459                         expectError(GL_INVALID_OPERATION);
1460                         glUniform2uiv(uvec4_f, 2, &data[0]);
1461                         expectError(GL_INVALID_OPERATION);
1462                         glUniform3uiv(uvec4_f, 2, &data[0]);
1463                         expectError(GL_INVALID_OPERATION);
1464                         glUniform4uiv(uvec4_f, 2, &data[0]);
1465                         expectError(GL_INVALID_OPERATION);
1466                         m_log << tcu::TestLog::EndSection;
1467
1468                         glUseProgram(0);
1469                 });
1470
1471
1472         // glUniformMatrix*fv
1473
1474         ES3F_ADD_API_CASE(uniform_matrixfv_invalid_program, "Invalid glUniformMatrix{234}fv() usage",
1475                 {
1476                         std::vector<GLfloat> data(16);
1477
1478                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1479                         glUseProgram(0);
1480                         glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1481                         expectError(GL_INVALID_OPERATION);
1482                         glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1483                         expectError(GL_INVALID_OPERATION);
1484                         glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1485                         expectError(GL_INVALID_OPERATION);
1486
1487                         glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1488                         expectError(GL_INVALID_OPERATION);
1489                         glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1490                         expectError(GL_INVALID_OPERATION);
1491                         glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1492                         expectError(GL_INVALID_OPERATION);
1493                         glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1494                         expectError(GL_INVALID_OPERATION);
1495                         glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1496                         expectError(GL_INVALID_OPERATION);
1497                         glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1498                         expectError(GL_INVALID_OPERATION);
1499                         m_log << tcu::TestLog::EndSection;
1500                 });
1501         ES3F_ADD_API_CASE(uniform_matrixfv_incompatible_type, "Invalid glUniformMatrix{234}fv() usage",
1502                 {
1503                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1504
1505                         glUseProgram                    (program.getProgram());
1506                         GLint mat4_v                    = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1507                         GLint sampler_f                 = glGetUniformLocation(program.getProgram(), "sampler_f");      // sampler2D
1508                         expectError(GL_NO_ERROR);
1509
1510                         if (mat4_v == -1 || sampler_f == -1)
1511                         {
1512                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1513                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1514                         }
1515
1516                         std::vector<GLfloat> data(16);
1517
1518                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1519                         glUseProgram(program.getProgram());
1520                         glUniformMatrix2fv(mat4_v, 1, GL_FALSE, &data[0]);
1521                         expectError(GL_INVALID_OPERATION);
1522                         glUniformMatrix3fv(mat4_v, 1, GL_FALSE, &data[0]);
1523                         expectError(GL_INVALID_OPERATION);
1524                         glUniformMatrix4fv(mat4_v, 1, GL_FALSE, &data[0]);
1525                         expectError(GL_NO_ERROR);
1526
1527                         glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1528                         expectError(GL_INVALID_OPERATION);
1529                         glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1530                         expectError(GL_INVALID_OPERATION);
1531                         glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1532                         expectError(GL_INVALID_OPERATION);
1533                         glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1534                         expectError(GL_INVALID_OPERATION);
1535                         glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1536                         expectError(GL_INVALID_OPERATION);
1537                         glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1538                         expectError(GL_INVALID_OPERATION);
1539                         m_log << tcu::TestLog::EndSection;
1540
1541                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1542                         glUseProgram(program.getProgram());
1543                         glUniformMatrix2fv(sampler_f, 1, GL_FALSE, &data[0]);
1544                         expectError(GL_INVALID_OPERATION);
1545                         glUniformMatrix3fv(sampler_f, 1, GL_FALSE, &data[0]);
1546                         expectError(GL_INVALID_OPERATION);
1547                         glUniformMatrix4fv(sampler_f, 1, GL_FALSE, &data[0]);
1548                         expectError(GL_INVALID_OPERATION);
1549
1550                         glUniformMatrix2x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1551                         expectError(GL_INVALID_OPERATION);
1552                         glUniformMatrix3x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1553                         expectError(GL_INVALID_OPERATION);
1554                         glUniformMatrix2x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1555                         expectError(GL_INVALID_OPERATION);
1556                         glUniformMatrix4x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1557                         expectError(GL_INVALID_OPERATION);
1558                         glUniformMatrix3x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1559                         expectError(GL_INVALID_OPERATION);
1560                         glUniformMatrix4x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1561                         expectError(GL_INVALID_OPERATION);
1562                         m_log << tcu::TestLog::EndSection;
1563
1564                         glUseProgram(0);
1565                 });
1566         ES3F_ADD_API_CASE(uniform_matrixfv_invalid_location, "Invalid glUniformMatrix{234}fv() usage",
1567                 {
1568                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1569
1570                         glUseProgram(program.getProgram());
1571                         expectError(GL_NO_ERROR);
1572
1573                         std::vector<GLfloat> data(16);
1574
1575                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1576                         glUseProgram(program.getProgram());
1577                         glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
1578                         expectError(GL_INVALID_OPERATION);
1579                         glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
1580                         expectError(GL_INVALID_OPERATION);
1581                         glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
1582                         expectError(GL_INVALID_OPERATION);
1583
1584                         glUniformMatrix2x3fv(-2, 1, GL_FALSE, &data[0]);
1585                         expectError(GL_INVALID_OPERATION);
1586                         glUniformMatrix3x2fv(-2, 1, GL_FALSE, &data[0]);
1587                         expectError(GL_INVALID_OPERATION);
1588                         glUniformMatrix2x4fv(-2, 1, GL_FALSE, &data[0]);
1589                         expectError(GL_INVALID_OPERATION);
1590                         glUniformMatrix4x2fv(-2, 1, GL_FALSE, &data[0]);
1591                         expectError(GL_INVALID_OPERATION);
1592                         glUniformMatrix3x4fv(-2, 1, GL_FALSE, &data[0]);
1593                         expectError(GL_INVALID_OPERATION);
1594                         glUniformMatrix4x3fv(-2, 1, GL_FALSE, &data[0]);
1595                         expectError(GL_INVALID_OPERATION);
1596
1597                         glUseProgram(program.getProgram());
1598                         glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1599                         expectError(GL_NO_ERROR);
1600                         glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1601                         expectError(GL_NO_ERROR);
1602                         glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1603                         expectError(GL_NO_ERROR);
1604
1605                         glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1606                         expectError(GL_NO_ERROR);
1607                         glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1608                         expectError(GL_NO_ERROR);
1609                         glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1610                         expectError(GL_NO_ERROR);
1611                         glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1612                         expectError(GL_NO_ERROR);
1613                         glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1614                         expectError(GL_NO_ERROR);
1615                         glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1616                         expectError(GL_NO_ERROR);
1617                         m_log << tcu::TestLog::EndSection;
1618
1619                         glUseProgram(0);
1620                 });
1621         ES3F_ADD_API_CASE(uniform_matrixfv_invalid_count, "Invalid glUniformMatrix{234}fv() usage",
1622                 {
1623                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1624
1625                         glUseProgram                    (program.getProgram());
1626                         GLint mat4_v                    = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1627                         expectError(GL_NO_ERROR);
1628
1629                         if (mat4_v == -1)
1630                         {
1631                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1632                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1633                         }
1634
1635                         std::vector<GLfloat> data(32);
1636
1637                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1638                         glUseProgram(program.getProgram());
1639                         glUniformMatrix2fv(mat4_v, 2, GL_FALSE, &data[0]);
1640                         expectError(GL_INVALID_OPERATION);
1641                         glUniformMatrix3fv(mat4_v, 2, GL_FALSE, &data[0]);
1642                         expectError(GL_INVALID_OPERATION);
1643                         glUniformMatrix4fv(mat4_v, 2, GL_FALSE, &data[0]);
1644                         expectError(GL_INVALID_OPERATION);
1645
1646                         glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1647                         expectError(GL_INVALID_OPERATION);
1648                         glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1649                         expectError(GL_INVALID_OPERATION);
1650                         glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1651                         expectError(GL_INVALID_OPERATION);
1652                         glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1653                         expectError(GL_INVALID_OPERATION);
1654                         glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1655                         expectError(GL_INVALID_OPERATION);
1656                         glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1657                         expectError(GL_INVALID_OPERATION);
1658                         m_log << tcu::TestLog::EndSection;
1659
1660                         glUseProgram(0);
1661                 });
1662
1663         // Transform feedback
1664
1665         ES3F_ADD_API_CASE(gen_transform_feedbacks, "Invalid glGenTransformFeedbacks() usage",
1666                 {
1667                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1668                         GLuint id;
1669                         glGenTransformFeedbacks(-1, &id);
1670                         expectError(GL_INVALID_VALUE);
1671                         m_log << tcu::TestLog::EndSection;
1672                 });
1673         ES3F_ADD_API_CASE(bind_transform_feedback, "Invalid glBindTransformFeedback() usage",
1674                 {
1675                         GLuint                                          tfID[2];
1676                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1677                         deUint32                                        buf;
1678                         const char* tfVarying           = "gl_Position";
1679
1680                         glGenBuffers                            (1, &buf);
1681                         glGenTransformFeedbacks         (2, tfID);
1682
1683                         m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK.");
1684                         glBindTransformFeedback(-1, tfID[0]);
1685                         expectError(GL_INVALID_ENUM);
1686                         m_log << tcu::TestLog::EndSection;
1687
1688                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the transform feedback operation is active on the currently bound transform feedback object, and is not paused.");
1689                         glUseProgram                            (program.getProgram());
1690                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1691                         glLinkProgram                           (program.getProgram());
1692                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID[0]);
1693                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1694                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1695                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1696                         glBeginTransformFeedback        (GL_TRIANGLES);
1697                         expectError                                     (GL_NO_ERROR);
1698
1699                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID[1]);
1700                         expectError                                     (GL_INVALID_OPERATION);
1701
1702                         glEndTransformFeedback          ();
1703                         expectError                                     (GL_NO_ERROR);
1704                         m_log << tcu::TestLog::EndSection;
1705
1706                         glUseProgram                            (0);
1707                         glDeleteBuffers                         (1, &buf);
1708                         glDeleteTransformFeedbacks      (2, tfID);
1709                         expectError                                     (GL_NO_ERROR);
1710                 });
1711         ES3F_ADD_API_CASE(delete_transform_feedbacks, "Invalid glDeleteTransformFeedbacks() usage",
1712                 {
1713                         GLuint id;
1714                         glGenTransformFeedbacks(1, &id);
1715
1716                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1717                         glDeleteTransformFeedbacks(-1, &id);
1718                         expectError(GL_INVALID_VALUE);
1719                         m_log << tcu::TestLog::EndSection;
1720
1721                         glDeleteTransformFeedbacks(1, &id);
1722                 });
1723         ES3F_ADD_API_CASE(begin_transform_feedback, "Invalid glBeginTransformFeedback() usage",
1724                 {
1725                         GLuint                                          tfID[2];
1726                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1727                         deUint32                                        buf;
1728                         const char* tfVarying           = "gl_Position";
1729
1730                         glGenBuffers                            (1, &buf);
1731                         glGenTransformFeedbacks         (2, tfID);
1732
1733                         glUseProgram                            (program.getProgram());
1734                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1735                         glLinkProgram                           (program.getProgram());
1736                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID[0]);
1737                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1738                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1739                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1740                         expectError                                     (GL_NO_ERROR);
1741
1742                         m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if primitiveMode is not one of GL_POINTS, GL_LINES, or GL_TRIANGLES.");
1743                         glBeginTransformFeedback        (-1);
1744                         expectError                                     (GL_INVALID_ENUM);
1745                         m_log << tcu::TestLog::EndSection;
1746
1747                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is already active.");
1748                         glBeginTransformFeedback        (GL_TRIANGLES);
1749                         expectError                                     (GL_NO_ERROR);
1750                         glBeginTransformFeedback        (GL_POINTS);
1751                         expectError                                     (GL_INVALID_OPERATION);
1752                         m_log << tcu::TestLog::EndSection;
1753
1754                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if any binding point used in transform feedback mode does not have a buffer object bound.");
1755                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
1756                         glBeginTransformFeedback        (GL_TRIANGLES);
1757                         expectError                                     (GL_INVALID_OPERATION);
1758                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1759                         m_log << tcu::TestLog::EndSection;
1760
1761                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if no binding points would be used because no program object is active.");
1762                         glUseProgram                            (0);
1763                         glBeginTransformFeedback        (GL_TRIANGLES);
1764                         expectError                                     (GL_INVALID_OPERATION);
1765                         glUseProgram                            (program.getProgram());
1766                         m_log << tcu::TestLog::EndSection;
1767
1768                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if no binding points would be used because the active program object has specified no varying variables to record.");
1769                         glTransformFeedbackVaryings     (program.getProgram(), 0, 0, GL_INTERLEAVED_ATTRIBS);
1770                         glBeginTransformFeedback        (GL_TRIANGLES);
1771                         expectError                                     (GL_INVALID_OPERATION);
1772                         m_log << tcu::TestLog::EndSection;
1773
1774                         glEndTransformFeedback          ();
1775                         glDeleteBuffers                         (1, &buf);
1776                         glDeleteTransformFeedbacks      (2, tfID);
1777                         expectError                                     (GL_NO_ERROR);
1778                 });
1779         ES3F_ADD_API_CASE(pause_transform_feedback, "Invalid glPauseTransformFeedback() usage",
1780                 {
1781                         GLuint                                          tfID[2];
1782                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1783                         deUint32                                        buf;
1784                         const char* tfVarying           = "gl_Position";
1785
1786                         glGenBuffers                            (1, &buf);
1787                         glGenTransformFeedbacks         (2, tfID);
1788
1789                         glUseProgram                            (program.getProgram());
1790                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1791                         glLinkProgram                           (program.getProgram());
1792                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID[0]);
1793                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1794                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1795                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1796                         expectError                                     (GL_NO_ERROR);
1797
1798                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is paused.");
1799                         glPauseTransformFeedback        ();
1800                         expectError                                     (GL_INVALID_OPERATION);
1801                         glBeginTransformFeedback        (GL_TRIANGLES);
1802                         glPauseTransformFeedback        ();
1803                         expectError                                     (GL_NO_ERROR);
1804                         glPauseTransformFeedback        ();
1805                         expectError                                     (GL_INVALID_OPERATION);
1806                         m_log << tcu::TestLog::EndSection;
1807
1808                         glEndTransformFeedback          ();
1809                         glDeleteBuffers                         (1, &buf);
1810                         glDeleteTransformFeedbacks      (2, tfID);
1811                         expectError                                     (GL_NO_ERROR);
1812                 });
1813         ES3F_ADD_API_CASE(resume_transform_feedback, "Invalid glResumeTransformFeedback() usage",
1814                 {
1815                         GLuint                                          tfID[2];
1816                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1817                         deUint32                                        buf;
1818                         const char* tfVarying           = "gl_Position";
1819
1820                         glGenBuffers                            (1, &buf);
1821                         glGenTransformFeedbacks         (2, tfID);
1822
1823                         glUseProgram                            (program.getProgram());
1824                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1825                         glLinkProgram                           (program.getProgram());
1826                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID[0]);
1827                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1828                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1829                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1830                         expectError                                     (GL_NO_ERROR);
1831
1832                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is not paused.");
1833                         glResumeTransformFeedback       ();
1834                         expectError                                     (GL_INVALID_OPERATION);
1835                         glBeginTransformFeedback        (GL_TRIANGLES);
1836                         glResumeTransformFeedback       ();
1837                         expectError                                     (GL_INVALID_OPERATION);
1838                         glPauseTransformFeedback        ();
1839                         glResumeTransformFeedback       ();
1840                         expectError                                     (GL_NO_ERROR);
1841                         m_log << tcu::TestLog::EndSection;
1842
1843                         glEndTransformFeedback          ();
1844                         glDeleteBuffers                         (1, &buf);
1845                         glDeleteTransformFeedbacks      (2, tfID);
1846                         expectError                                     (GL_NO_ERROR);
1847                 });
1848         ES3F_ADD_API_CASE(end_transform_feedback, "Invalid glEndTransformFeedback() usage",
1849                 {
1850                         GLuint                                          tfID;
1851                         glu::ShaderProgram                      program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1852                         deUint32                                        buf;
1853                         const char* tfVarying           = "gl_Position";
1854
1855                         glGenBuffers                            (1, &buf);
1856                         glGenTransformFeedbacks         (1, &tfID);
1857
1858                         glUseProgram                            (program.getProgram());
1859                         glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1860                         glLinkProgram                           (program.getProgram());
1861                         glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
1862                         glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1863                         glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1864                         glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1865                         expectError                                     (GL_NO_ERROR);
1866
1867                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is not active.");
1868                         glEndTransformFeedback          ();
1869                         expectError                                     (GL_INVALID_OPERATION);
1870                         glBeginTransformFeedback        (GL_TRIANGLES);
1871                         glEndTransformFeedback          ();
1872                         expectError                                     (GL_NO_ERROR);
1873                         m_log << tcu::TestLog::EndSection;
1874
1875                         glDeleteBuffers                         (1, &buf);
1876                         glDeleteTransformFeedbacks      (1, &tfID);
1877                         expectError                                     (GL_NO_ERROR);
1878                 });
1879         ES3F_ADD_API_CASE(get_transform_feedback_varying, "Invalid glGetTransformFeedbackVarying() usage",
1880                 {
1881                         GLuint                                  tfID;
1882                         glu::ShaderProgram              program                 (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1883                         glu::ShaderProgram              programInvalid  (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
1884                         const char* tfVarying   = "gl_Position";
1885                         int                                             maxTransformFeedbackVaryings = 0;
1886
1887                         GLsizei                                 length;
1888                         GLsizei                                 size;
1889                         GLenum                                  type;
1890                         char                                    name[32];
1891
1892                         glGenTransformFeedbacks                 (1, &tfID);
1893
1894                         glTransformFeedbackVaryings             (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1895                         expectError                                             (GL_NO_ERROR);
1896                         glLinkProgram                                   (program.getProgram());
1897                         expectError                                             (GL_NO_ERROR);
1898
1899                         glBindTransformFeedback                 (GL_TRANSFORM_FEEDBACK, tfID);
1900                         expectError                                             (GL_NO_ERROR);
1901
1902                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object.");
1903                         glGetTransformFeedbackVarying   (-1, 0, 32, &length, &size, &type, &name[0]);
1904                         expectError                                             (GL_INVALID_VALUE);
1905                         m_log << tcu::TestLog::EndSection;
1906
1907                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater or equal to the value of GL_TRANSFORM_FEEDBACK_VARYINGS.");
1908                         glGetProgramiv                                  (program.getProgram(), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxTransformFeedbackVaryings);
1909                         glGetTransformFeedbackVarying   (program.getProgram(), maxTransformFeedbackVaryings, 32, &length, &size, &type, &name[0]);
1910                         expectError                                             (GL_INVALID_VALUE);
1911                         m_log << tcu::TestLog::EndSection;
1912
1913                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION or GL_INVALID_VALUE is generated program has not been linked.");
1914                         glGetTransformFeedbackVarying   (programInvalid.getProgram(), 0, 32, &length, &size, &type, &name[0]);
1915                         expectError                                             (GL_INVALID_OPERATION, GL_INVALID_VALUE);
1916                         m_log << tcu::TestLog::EndSection;
1917
1918                         glDeleteTransformFeedbacks              (1, &tfID);
1919                         expectError                                             (GL_NO_ERROR);
1920                 });
1921         ES3F_ADD_API_CASE(transform_feedback_varyings, "Invalid glTransformFeedbackVaryings() usage",
1922                 {
1923                         GLuint                                  tfID;
1924                         glu::ShaderProgram              program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1925                         const char* tfVarying   = "gl_Position";
1926                         GLint                                   maxTransformFeedbackSeparateAttribs = 0;
1927
1928                         glGenTransformFeedbacks                 (1, &tfID);
1929                         expectError                                             (GL_NO_ERROR);
1930
1931                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object.");
1932                         glTransformFeedbackVaryings             (0, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1933                         expectError                                             (GL_INVALID_VALUE);
1934                         m_log << tcu::TestLog::EndSection;
1935
1936                         m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
1937                         glGetIntegerv                                   (GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
1938                         glTransformFeedbackVaryings             (program.getProgram(), maxTransformFeedbackSeparateAttribs+1, &tfVarying, GL_SEPARATE_ATTRIBS);
1939                         expectError                                             (GL_INVALID_VALUE);
1940                         m_log << tcu::TestLog::EndSection;
1941
1942                         glDeleteTransformFeedbacks              (1, &tfID);
1943                         expectError                                             (GL_NO_ERROR);
1944                 });
1945 }
1946
1947 } // Functional
1948 } // gles3
1949 } // deqp