modules/gles2/functional/es2fNegativeShaderApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.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 "es2fNegativeShaderApiTests.hpp"
  25 #include "es2fApiCase.hpp"
  26 #include "gluShaderProgram.hpp"
  27 #include "gluContextInfo.hpp"
  28
  29 #include "glwDefs.hpp"
  30 #include "glwEnums.hpp"
  31
  32 #include "deStringUtil.hpp"
  33
  34 using namespace glw; // GL types
  35
  36 namespace deqp
  37 {
  38 namespace gles2
  39 {
  40 namespace Functional
  41 {
  42
  43 static const char* vertexShaderSource   = "void main (void) { gl_Position = vec4(0.0); }\n\0";
  44 static const char* fragmentShaderSource = "void main (void) { gl_FragColor = vec4(0.0); }\n\0";
  45
  46 static const char* uniformTestVertSource        =       "uniform mediump vec4 vTest;\n"
  47                                                                                                 "uniform mediump mat4 vMatrix;\n"
  48                                                                                                 "void main (void)\n"
  49                                                                                                 "{\n"
  50                                                                                                 "       gl_Position = vMatrix * vTest;\n"
  51                                                                                                 "}\n\0";
  52 static const char* uniformTestFragSource        =       "uniform mediump ivec4 fTest;\n"
  53                                                                                                 "uniform sampler2D fSampler;\n"
  54                                                                                                 "void main (void)\n"
  55                                                                                                 "{\n"
  56                                                                                                 "       gl_FragColor.xy = vec4(fTest).xy;\n"
  57                                                                                                 "       gl_FragColor.zw = texture2D(fSampler, vec2(0.0, 0.0)).zw;\n"
  58                                                                                                 "}\n\0";
  59
  60 using tcu::TestLog;
  61
  62 NegativeShaderApiTests::NegativeShaderApiTests (Context& context)
  63         : TestCaseGroup(context, "shader", "Negative Shader API Cases")
  64 {
  65 }
  66
  67 NegativeShaderApiTests::~NegativeShaderApiTests (void)
  68 {
  69 }
  70
  71 void NegativeShaderApiTests::init (void)
  72 {
  73         ES2F_ADD_API_CASE(create_shader, "Invalid glCreateShader() usage",
  74                 {
  75                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
  76                         glCreateShader(-1);
  77                         expectError(GL_INVALID_ENUM);
  78                         m_log << TestLog::EndSection;
  79                 });
  80         ES2F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage",
  81                 {
  82                         GLboolean shaderCompilerSupported;
  83                         glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
  84                         if (!shaderCompilerSupported)
  85                                 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
  86                         else
  87                                 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
  88
  89                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
  90                         glShaderSource(1, 0, 0, 0);
  91                         expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
  92                         m_log << TestLog::EndSection;
  93
  94                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if count is less than 0.");
  95                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
  96                         glShaderSource(shader, -1, 0, 0);
  97                         expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
  98                         m_log << TestLog::EndSection;
  99
 100                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 101                         GLuint program = glCreateProgram();
 102                         glShaderSource(program, 0, 0, 0);
 103                         expectError(GL_INVALID_OPERATION);
 104                         m_log << TestLog::EndSection;
 105
 106                         glDeleteProgram(program);
 107                         glDeleteShader(shader);
 108                 });
 109         ES2F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage",
 110                 {
 111                         GLboolean shaderCompilerSupported;
 112                         glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 113                         if (!shaderCompilerSupported)
 114                                 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
 115                         else
 116                                 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
 117
 118                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 119                         glCompileShader(9);
 120                         expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
 121                         m_log << TestLog::EndSection;
 122
 123                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 124                         GLuint program = glCreateProgram();
 125                         glCompileShader(program);
 126                         expectError(GL_INVALID_OPERATION);
 127                         m_log << TestLog::EndSection;
 128
 129                         glDeleteProgram(program);
 130                 });
 131         ES2F_ADD_API_CASE(delete_shader, "Invalid glDeleteShader() usage",
 132                 {
 133                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 134                         glDeleteShader(9);
 135                         expectError(GL_INVALID_VALUE);
 136                         m_log << TestLog::EndSection;
 137                 });
 138         ES2F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage",
 139                 {
 140                         std::vector<deInt32> binaryFormats;
 141                         getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
 142                         deBool shaderBinarySupported = !binaryFormats.empty();
 143                         if (!shaderBinarySupported)
 144                                 m_log << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
 145                         else
 146                                 m_log << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
 147
 148                         GLuint shaders[2];
 149
 150                         shaders[0] = glCreateShader(GL_VERTEX_SHADER);
 151                         shaders[1] = glCreateShader(GL_VERTEX_SHADER);
 152                         GLuint program = glCreateProgram();
 153
 154                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryformat is not a supported format returned in GL_SHADER_BINARY_FORMATS.");
 155                         glShaderBinary(1, &shaders[0], -1, 0, 0);
 156                         expectError(GL_INVALID_ENUM);
 157                         m_log << TestLog::EndSection;
 158
 159                         if (shaderBinarySupported)
 160                         {
 161                                 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if any value in shaders is not a value generated by OpenGL.");
 162                                 shaders[0] = 137;
 163                                 glShaderBinary(1, &shaders[0], binaryFormats[0], 0, 0);
 164                                 expectError(shaderBinarySupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
 165                                 m_log << TestLog::EndSection;
 166
 167                                 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n or length is negative.");
 168                                 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
 169                                 glShaderBinary(-1, &shaders[0], binaryFormats[0], 0, 0);
 170                                 expectError(GL_INVALID_VALUE);
 171                                 glShaderBinary(1, &shaders[0], binaryFormats[0], 0, -1);
 172                                 expectError(GL_INVALID_VALUE);
 173                                 m_log << TestLog::EndSection;
 174
 175                                 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if any value in shaders is not a shader object.");
 176                                 glShaderBinary(1, &program, binaryFormats[0], 0, 0);
 177                                 expectError(GL_INVALID_OPERATION);
 178                                 m_log << TestLog::EndSection;
 179
 180                                 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if there is more than one vertex shader object handle or more than one fragment shader object handle in shaders.");
 181                                 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
 182                                 shaders[1] = glCreateShader(GL_VERTEX_SHADER);
 183                                 glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 1);
 184                                 expectError(GL_INVALID_OPERATION);
 185                                 m_log << TestLog::EndSection;
 186                         }
 187
 188                         glDeleteShader(shaders[0]);
 189                         glDeleteShader(shaders[1]);
 190                         glDeleteProgram(program);
 191
 192                         // \note: The format of the data pointed to by binary does not match binaryformat.
 193                 });
 194         ES2F_ADD_API_CASE(attach_shader, "Invalid glAttachShader() usage",
 195                 {
 196                         GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
 197                         GLuint shader2 = glCreateShader(GL_VERTEX_SHADER);
 198                         GLuint program = glCreateProgram();
 199
 200                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 201                         glAttachShader(shader1, shader1);
 202                         expectError(GL_INVALID_OPERATION);
 203                         m_log << TestLog::EndSection;
 204
 205                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 206                         glAttachShader(program, program);
 207                         expectError(GL_INVALID_OPERATION);
 208                         glAttachShader(shader1, program);
 209                         expectError(GL_INVALID_OPERATION);
 210                         m_log << TestLog::EndSection;
 211
 212                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
 213                         glAttachShader(program, -1);
 214                         expectError(GL_INVALID_VALUE);
 215                         glAttachShader(-1, shader1);
 216                         expectError(GL_INVALID_VALUE);
 217                         glAttachShader(-1, -1);
 218                         expectError(GL_INVALID_VALUE);
 219                         m_log << TestLog::EndSection;
 220
 221                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is already attached to program, or if another shader object of the same type as shader is already attached to program.");
 222                         glAttachShader(program, shader1);
 223                         expectError(GL_NO_ERROR);
 224                         glAttachShader(program, shader1);
 225                         expectError(GL_INVALID_OPERATION);
 226                         glAttachShader(program, shader2);
 227                         expectError(GL_INVALID_OPERATION);
 228                         m_log << TestLog::EndSection;
 229
 230                         glDeleteProgram(program);
 231                         glDeleteShader(shader1);
 232                         glDeleteShader(shader2);
 233                 });
 234         ES2F_ADD_API_CASE(detach_shader, "Invalid glDetachShader() usage",
 235                 {
 236                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 237                         GLuint program = glCreateProgram();
 238
 239                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
 240                         glDetachShader(-1, shader);
 241                         expectError(GL_INVALID_VALUE);
 242                         glDetachShader(program, -1);
 243                         expectError(GL_INVALID_VALUE);
 244                         glDetachShader(-1, -1);
 245                         expectError(GL_INVALID_VALUE);
 246                         m_log << TestLog::EndSection;
 247
 248                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 249                         glDetachShader(shader, shader);
 250                         expectError(GL_INVALID_OPERATION);
 251                         m_log << TestLog::EndSection;
 252
 253                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 254                         glDetachShader(program, program);
 255                         expectError(GL_INVALID_OPERATION);
 256                         glDetachShader(shader, program);
 257                         expectError(GL_INVALID_OPERATION);
 258                         m_log << TestLog::EndSection;
 259
 260                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not attached to program.");
 261                         glDetachShader(program, shader);
 262                         expectError(GL_INVALID_OPERATION);
 263                         m_log << TestLog::EndSection;
 264
 265                         glDeleteProgram(program);
 266                         glDeleteShader(shader);
 267                 });
 268         ES2F_ADD_API_CASE(link_program, "Invalid glLinkProgram() usage",
 269                 {
 270                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 271
 272                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 273                         glLinkProgram(-1);
 274                         expectError(GL_INVALID_VALUE);
 275                         m_log << TestLog::EndSection;
 276
 277                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 278                         glLinkProgram(shader);
 279                         expectError(GL_INVALID_OPERATION);
 280                         m_log << TestLog::EndSection;
 281
 282                         glDeleteShader(shader);
 283                 });
 284         ES2F_ADD_API_CASE(use_program, "Invalid glUseProgram() usage",
 285                 {
 286                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 287
 288                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
 289                         glUseProgram(-1);
 290                         expectError(GL_INVALID_VALUE);
 291                         m_log << TestLog::EndSection;
 292
 293                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 294                         glUseProgram(shader);
 295                         expectError(GL_INVALID_OPERATION);
 296                         m_log << TestLog::EndSection;
 297
 298                         glUseProgram(0);
 299                         glDeleteShader(shader);
 300                 });
 301         ES2F_ADD_API_CASE(delete_program, "Invalid glDeleteProgram() usage",
 302                 {
 303                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 304                         glDeleteProgram(-1);
 305                         expectError(GL_INVALID_VALUE);
 306                         m_log << TestLog::EndSection;
 307                 });
 308         ES2F_ADD_API_CASE(get_active_attrib, "Invalid glGetActiveAttrib() usage",
 309                 {
 310                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 311                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 312                         glUseProgram(program.getProgram());
 313
 314                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 315                         glGetActiveAttrib(-1, 0, 0, 0, 0, 0, 0);
 316                         expectError(GL_INVALID_VALUE);
 317                         m_log << TestLog::EndSection;
 318
 319                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 320                         glGetActiveAttrib(shader, 0, 0, 0, 0, 0, 0);
 321                         expectError(GL_INVALID_OPERATION);
 322                         m_log << TestLog::EndSection;
 323
 324                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number of active attribute variables in program.");
 325                         glGetActiveAttrib(program.getProgram(), 0, 0, 0, 0, 0, 0);
 326                         expectError(GL_INVALID_VALUE);
 327                         m_log << TestLog::EndSection;
 328
 329                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
 330                         glGetActiveAttrib(program.getProgram(), 0, -1, 0, 0, 0, 0);
 331                         expectError(GL_INVALID_VALUE);
 332                         m_log << TestLog::EndSection;
 333
 334                         glUseProgram(0);
 335                         glDeleteShader(shader);
 336                 });
 337         ES2F_ADD_API_CASE(get_attrib_location, "Invalid glGetAttribLocation() usage",
 338                 {
 339                         GLuint programEmpty = glCreateProgram();
 340                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 341                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 342
 343                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 344                         glBindAttribLocation(programEmpty, 0, "test");
 345                         glGetAttribLocation(programEmpty, "test");
 346                         expectError(GL_INVALID_OPERATION);
 347                         m_log << TestLog::EndSection;
 348
 349                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a program or shader object.");
 350                         glUseProgram(program.getProgram());
 351                         glBindAttribLocation(program.getProgram(), 0, "test");
 352                         expectError(GL_NO_ERROR);
 353                         glGetAttribLocation(program.getProgram(), "test");
 354                         expectError(GL_NO_ERROR);
 355                         glGetAttribLocation(-2, "test");
 356                         expectError(GL_INVALID_VALUE);
 357                         m_log << TestLog::EndSection;
 358
 359                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 360                         glGetAttribLocation(shader, "test");
 361                         expectError(GL_INVALID_OPERATION);
 362                         m_log << TestLog::EndSection;
 363
 364                         glUseProgram(0);
 365                         glDeleteShader(shader);
 366                         glDeleteProgram(programEmpty);
 367                 });
 368         ES2F_ADD_API_CASE(get_uniform_location, "Invalid glGetUniformLocation() usage",
 369                 {
 370                         GLuint programEmpty = glCreateProgram();
 371                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 372                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 373
 374                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 375                         glGetUniformLocation(programEmpty, "test");
 376                         expectError(GL_INVALID_OPERATION);
 377                         m_log << TestLog::EndSection;
 378
 379                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 380                         glUseProgram(program.getProgram());
 381                         glGetUniformLocation(-2, "test");
 382                         expectError(GL_INVALID_VALUE);
 383                         m_log << TestLog::EndSection;
 384
 385                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 386                         glGetAttribLocation(shader, "test");
 387                         expectError(GL_INVALID_OPERATION);
 388                         m_log << TestLog::EndSection;
 389
 390                         glUseProgram(0);
 391                         glDeleteProgram(programEmpty);
 392                         glDeleteShader(shader);
 393                 });
 394         ES2F_ADD_API_CASE(bind_attrib_location, "Invalid glBindAttribLocation() usage",
 395                 {
 396                         GLuint program = glCreateProgram();
 397                         GLuint maxIndex = m_context.getContextInfo().getInt(GL_MAX_VERTEX_ATTRIBS);
 398                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 399
 400                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 401                         glBindAttribLocation(program, maxIndex, "test");
 402                         expectError(GL_INVALID_VALUE);
 403                         m_log << TestLog::EndSection;
 404
 405                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
 406                         glBindAttribLocation(program, maxIndex-1, "gl_test");
 407                         expectError(GL_INVALID_OPERATION);
 408                         m_log << TestLog::EndSection;
 409
 410                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 411                         glBindAttribLocation(-1, maxIndex-1, "test");
 412                         expectError(GL_INVALID_VALUE);
 413                         m_log << TestLog::EndSection;
 414
 415                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 416                         glBindAttribLocation(shader, maxIndex-1, "test");
 417                         expectError(GL_INVALID_OPERATION);
 418                         m_log << TestLog::EndSection;
 419
 420                         glDeleteProgram(program);
 421                         glDeleteShader(shader);
 422                 });
 423         ES2F_ADD_API_CASE(get_active_uniform, "Invalid glGetActiveUniform() usage",
 424                 {
 425                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 426                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
 427
 428                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 429                         glGetActiveUniform(-1, 0, 0, 0, 0, 0, 0);
 430                         expectError(GL_INVALID_VALUE);
 431                         m_log << TestLog::EndSection;
 432
 433                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 434                         glGetActiveUniform(shader, 0, 0, 0, 0, 0, 0);
 435                         expectError(GL_INVALID_OPERATION);
 436                         m_log << TestLog::EndSection;
 437
 438                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number of active attribute variables in program.");
 439                         glUseProgram(program.getProgram());
 440                         glGetActiveUniform(program.getProgram(), 5, 0, 0, 0, 0, 0);
 441                         expectError(GL_INVALID_VALUE);
 442                         m_log << TestLog::EndSection;
 443
 444                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
 445                         glGetActiveUniform(program.getProgram(), 0, -1, 0, 0, 0, 0);
 446                         expectError(GL_INVALID_VALUE);
 447                         m_log << TestLog::EndSection;
 448
 449                         glUseProgram(0);
 450                         glDeleteShader(shader);
 451                 });
 452         ES2F_ADD_API_CASE(validate_program, "Invalid glValidateProgram() usage",
 453                 {
 454                         GLuint shader = glCreateShader(GL_VERTEX_SHADER);
 455
 456                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 457                         glValidateProgram(-1);
 458                         expectError(GL_INVALID_VALUE);
 459                         m_log << TestLog::EndSection;
 460
 461                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 462                         glValidateProgram(shader);
 463                         expectError(GL_INVALID_OPERATION);
 464                         m_log << TestLog::EndSection;
 465
 466                         glDeleteShader(shader);
 467                 });
 468
 469         ES2F_ADD_API_CASE(release_shader_compiler, "Invalid glReleaseShaderCompiler() usage",
 470                 {
 471                         GLboolean shaderCompilerSupported;
 472                         glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 473
 474                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader compiler is not supported.");
 475                         glReleaseShaderCompiler();
 476                         expectError(shaderCompilerSupported ? GL_NONE : GL_INVALID_OPERATION);
 477                         m_log << TestLog::EndSection;
 478                 });
 479
 480         // glUniform*f
 481
 482         ES2F_ADD_API_CASE(uniformf_invalid_program, "Invalid glUniform{1234}f() usage",
 483                 {
 484                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 485                         glUseProgram(0);
 486                         glUniform1f(-1, 0.0f);
 487                         expectError(GL_INVALID_OPERATION);
 488                         glUniform2f(-1, 0.0f, 0.0f);
 489                         expectError(GL_INVALID_OPERATION);
 490                         glUniform3f(-1, 0.0f, 0.0f, 0.0f);
 491                         expectError(GL_INVALID_OPERATION);
 492                         glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
 493                         expectError(GL_INVALID_OPERATION);
 494                         m_log << tcu::TestLog::EndSection;
 495                 });
 496         ES2F_ADD_API_CASE(uniformf_incompatible_type, "Invalid glUniform{1234}f() usage",
 497                 {
 498                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 499                         glUseProgram(program.getProgram());
 500                         GLint vUnif             = glGetUniformLocation(program.getProgram(), "vTest");          // vec4
 501                         GLint fUnif             = glGetUniformLocation(program.getProgram(), "fTest");          // ivec4
 502                         GLint fSampler  = glGetUniformLocation(program.getProgram(), "fSampler");       // sampler2D
 503
 504                         if (vUnif == -1 || fUnif == -1 || fSampler == -1)
 505                                 {
 506                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 507                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 508                         }
 509
 510                         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.");
 511                         glUseProgram(program.getProgram());
 512                         glUniform1f(vUnif, 0.0f);
 513                         expectError(GL_INVALID_OPERATION);
 514                         glUniform2f(vUnif, 0.0f, 0.0f);
 515                         expectError(GL_INVALID_OPERATION);
 516                         glUniform3f(vUnif, 0.0f, 0.0f, 0.0f);
 517                         expectError(GL_INVALID_OPERATION);
 518                         glUniform4f(vUnif, 0.0f, 0.0f, 0.0f, 0.0f);
 519                         expectError(GL_NO_ERROR);
 520                         m_log << tcu::TestLog::EndSection;
 521
 522                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the floating-point variants of this function is used to load a uniform variable of type int, ivec2, ivec3, or ivec4.");
 523                         glUseProgram(program.getProgram());
 524                         glUniform4f(fUnif, 0.0f, 0.0f, 0.0f, 0.0f);
 525                         expectError(GL_INVALID_OPERATION);
 526                         m_log << tcu::TestLog::EndSection;
 527
 528                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
 529                         glUseProgram(program.getProgram());
 530                         glUniform1f(fSampler, 0.0f);
 531                         expectError(GL_INVALID_OPERATION);
 532                         m_log << tcu::TestLog::EndSection;
 533
 534                         glUseProgram(0);
 535                 });
 536         ES2F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage",
 537                 {
 538                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 539                         glUseProgram(program.getProgram());
 540
 541                         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.");
 542                         glUseProgram(program.getProgram());
 543                         glUniform1f(-2, 0.0f);
 544                         expectError(GL_INVALID_OPERATION);
 545                         glUniform2f(-2, 0.0f, 0.0f);
 546                         expectError(GL_INVALID_OPERATION);
 547                         glUniform3f(-2, 0.0f, 0.0f, 0.0f);
 548                         expectError(GL_INVALID_OPERATION);
 549                         glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
 550                         expectError(GL_INVALID_OPERATION);
 551
 552                         glUseProgram(program.getProgram());
 553                         glUniform1f(-1, 0.0f);
 554                         expectError(GL_NO_ERROR);
 555                         glUniform2f(-1, 0.0f, 0.0f);
 556                         expectError(GL_NO_ERROR);
 557                         glUniform3f(-1, 0.0f, 0.0f, 0.0f);
 558                         expectError(GL_NO_ERROR);
 559                         glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
 560                         expectError(GL_NO_ERROR);
 561                         m_log << tcu::TestLog::EndSection;
 562
 563                         glUseProgram(0);
 564                 });
 565
 566         // glUniform*fv
 567
 568         ES2F_ADD_API_CASE(uniformfv_invalid_program, "Invalid glUniform{1234}fv() usage",
 569                 {
 570                         std::vector<GLfloat> data(4);
 571
 572                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 573                         glUseProgram(0);
 574                         glUniform1fv(-1, 1, &data[0]);
 575                         expectError(GL_INVALID_OPERATION);
 576                         glUniform2fv(-1, 1, &data[0]);
 577                         expectError(GL_INVALID_OPERATION);
 578                         glUniform3fv(-1, 1, &data[0]);
 579                         expectError(GL_INVALID_OPERATION);
 580                         glUniform4fv(-1, 1, &data[0]);
 581                         expectError(GL_INVALID_OPERATION);
 582                         m_log << tcu::TestLog::EndSection;
 583                 });
 584         ES2F_ADD_API_CASE(uniformfv_incompatible_type, "Invalid glUniform{1234}fv() usage",
 585                 {
 586                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 587                         glUseProgram(program.getProgram());
 588                         GLint vUnif             = glGetUniformLocation(program.getProgram(), "vTest");          // vec4
 589                         GLint fUnif             = glGetUniformLocation(program.getProgram(), "fTest");          // ivec4
 590                         GLint fSampler  = glGetUniformLocation(program.getProgram(), "fSampler");       // sampler2D
 591
 592                         if (vUnif == -1 || fUnif == -1 || fSampler == -1)
 593                         {
 594                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 595                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 596                         }
 597
 598                         std::vector<GLfloat> data(4);
 599
 600                         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.");
 601                         glUseProgram(program.getProgram());
 602                         glUniform1fv(vUnif, 1, &data[0]);
 603                         expectError(GL_INVALID_OPERATION);
 604                         glUniform2fv(vUnif, 1, &data[0]);
 605                         expectError(GL_INVALID_OPERATION);
 606                         glUniform3fv(vUnif, 1, &data[0]);
 607                         expectError(GL_INVALID_OPERATION);
 608                         glUniform4fv(vUnif, 1, &data[0]);
 609                         expectError(GL_NO_ERROR);
 610                         m_log << tcu::TestLog::EndSection;
 611
 612                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the floating-point variants of this function is used to load a uniform variable of type int, ivec2, ivec3, or ivec4.");
 613                         glUseProgram(program.getProgram());
 614                         glUniform4fv(fUnif, 1, &data[0]);
 615                         expectError(GL_INVALID_OPERATION);
 616                         m_log << tcu::TestLog::EndSection;
 617
 618                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
 619                         glUseProgram(program.getProgram());
 620                         glUniform1fv(fSampler, 1, &data[0]);
 621                         expectError(GL_INVALID_OPERATION);
 622                         m_log << tcu::TestLog::EndSection;
 623
 624                         glUseProgram(0);
 625                 });
 626         ES2F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage",
 627                 {
 628                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 629                         glUseProgram(program.getProgram());
 630
 631                         std::vector<GLfloat> data(4);
 632
 633                         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.");
 634                         glUseProgram(program.getProgram());
 635                         glUniform1fv(-2, 1, &data[0]);
 636                         expectError(GL_INVALID_OPERATION);
 637                         glUniform2fv(-2, 1, &data[0]);
 638                         expectError(GL_INVALID_OPERATION);
 639                         glUniform3fv(-2, 1, &data[0]);
 640                         expectError(GL_INVALID_OPERATION);
 641                         glUniform4fv(-2, 1, &data[0]);
 642                         expectError(GL_INVALID_OPERATION);
 643
 644                         glUseProgram(program.getProgram());
 645                         glUniform1fv(-1, 1, &data[0]);
 646                         expectError(GL_NO_ERROR);
 647                         glUniform2fv(-1, 1, &data[0]);
 648                         expectError(GL_NO_ERROR);
 649                         glUniform3fv(-1, 1, &data[0]);
 650                         expectError(GL_NO_ERROR);
 651                         glUniform4fv(-1, 1, &data[0]);
 652                         expectError(GL_NO_ERROR);
 653                         m_log << tcu::TestLog::EndSection;
 654
 655                         glUseProgram(0);
 656                 });
 657         ES2F_ADD_API_CASE(uniformfv_invalid_count, "Invalid glUniform{1234}fv() usage",
 658                 {
 659                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 660                         glUseProgram(program.getProgram());
 661                         GLint vUnif             = glGetUniformLocation(program.getProgram(), "vTest");          // vec4
 662
 663                         if (vUnif == -1)
 664                         {
 665                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 666                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 667                         }
 668
 669                         std::vector<GLfloat> data(8);
 670
 671                         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.");
 672                         glUseProgram(program.getProgram());
 673                         glUniform1fv(vUnif, 2, &data[0]);
 674                         expectError(GL_INVALID_OPERATION);
 675                         glUniform2fv(vUnif, 2, &data[0]);
 676                         expectError(GL_INVALID_OPERATION);
 677                         glUniform3fv(vUnif, 2, &data[0]);
 678                         expectError(GL_INVALID_OPERATION);
 679                         glUniform4fv(vUnif, 2, &data[0]);
 680                         expectError(GL_INVALID_OPERATION);
 681                         m_log << tcu::TestLog::EndSection;
 682
 683                         glUseProgram(0);
 684                 });
 685
 686         // glUniform*i
 687
 688         ES2F_ADD_API_CASE(uniformi_invalid_program, "Invalid glUniform{1234}i() usage",
 689                 {
 690                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 691                         glUseProgram(0);
 692                         glUniform1i(-1, 0);
 693                         expectError(GL_INVALID_OPERATION);
 694                         glUniform2i(-1, 0, 0);
 695                         expectError(GL_INVALID_OPERATION);
 696                         glUniform3i(-1, 0, 0, 0);
 697                         expectError(GL_INVALID_OPERATION);
 698                         glUniform4i(-1, 0, 0, 0, 0);
 699                         expectError(GL_INVALID_OPERATION);
 700                         m_log << tcu::TestLog::EndSection;
 701                 });
 702         ES2F_ADD_API_CASE(uniformi_incompatible_type, "Invalid glUniform{1234}i() usage",
 703                 {
 704                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 705                         glUseProgram(program.getProgram());
 706                         GLint vUnif             = glGetUniformLocation(program.getProgram(), "vTest");          // vec4
 707                         GLint fUnif             = glGetUniformLocation(program.getProgram(), "fTest");          // ivec4
 708                         GLint fSampler  = glGetUniformLocation(program.getProgram(), "fSampler");       // sampler2D
 709
 710                         if (vUnif == -1 || fUnif == -1 || fSampler == -1)
 711                         {
 712                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 713                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 714                         }
 715
 716                         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.");
 717                         glUseProgram(program.getProgram());
 718                         glUniform1i(fUnif, 0);
 719                         expectError(GL_INVALID_OPERATION);
 720                         glUniform2i(fUnif, 0, 0);
 721                         expectError(GL_INVALID_OPERATION);
 722                         glUniform3i(fUnif, 0, 0, 0);
 723                         expectError(GL_INVALID_OPERATION);
 724                         glUniform4i(fUnif, 0, 0, 0, 0);
 725                         expectError(GL_NO_ERROR);
 726                         m_log << tcu::TestLog::EndSection;
 727
 728                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a uniform variable of type float, vec2, vec3, or vec4.");
 729                         glUseProgram(program.getProgram());
 730                         glUniform4i(vUnif, 0, 0, 0, 0);
 731                         expectError(GL_INVALID_OPERATION);
 732                         m_log << tcu::TestLog::EndSection;
 733
 734                         glUseProgram(0);
 735                 });
 736         ES2F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage",
 737                 {
 738                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 739                         glUseProgram(program.getProgram());
 740
 741                         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.");
 742                         glUseProgram(program.getProgram());
 743                         glUniform1i(-2, 0);
 744                         expectError(GL_INVALID_OPERATION);
 745                         glUniform2i(-2, 0, 0);
 746                         expectError(GL_INVALID_OPERATION);
 747                         glUniform3i(-2, 0, 0, 0);
 748                         expectError(GL_INVALID_OPERATION);
 749                         glUniform4i(-2, 0, 0, 0, 0);
 750                         expectError(GL_INVALID_OPERATION);
 751
 752                         glUseProgram(program.getProgram());
 753                         glUniform1i(-1, 0);
 754                         expectError(GL_NO_ERROR);
 755                         glUniform2i(-1, 0, 0);
 756                         expectError(GL_NO_ERROR);
 757                         glUniform3i(-1, 0, 0, 0);
 758                         expectError(GL_NO_ERROR);
 759                         glUniform4i(-1, 0, 0, 0, 0);
 760                         expectError(GL_NO_ERROR);
 761                         m_log << tcu::TestLog::EndSection;
 762
 763                         glUseProgram(0);
 764                 });
 765
 766         // glUniform*iv
 767
 768         ES2F_ADD_API_CASE(uniformiv_invalid_program, "Invalid glUniform{1234}iv() usage",
 769                 {
 770                         std::vector<GLint> data(4);
 771
 772                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 773                         glUseProgram(0);
 774                         glUniform1iv(-1, 1, &data[0]);
 775                         expectError(GL_INVALID_OPERATION);
 776                         glUniform2iv(-1, 1, &data[0]);
 777                         expectError(GL_INVALID_OPERATION);
 778                         glUniform3iv(-1, 1, &data[0]);
 779                         expectError(GL_INVALID_OPERATION);
 780                         glUniform4iv(-1, 1, &data[0]);
 781                         expectError(GL_INVALID_OPERATION);
 782                         m_log << tcu::TestLog::EndSection;
 783                 });
 784         ES2F_ADD_API_CASE(uniformiv_incompatible_type, "Invalid glUniform{1234}iv() usage",
 785                 {
 786                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 787                         glUseProgram(program.getProgram());
 788                         GLint vUnif             = glGetUniformLocation(program.getProgram(), "vTest");          // vec4
 789                         GLint fUnif             = glGetUniformLocation(program.getProgram(), "fTest");          // ivec4
 790                         GLint fSampler  = glGetUniformLocation(program.getProgram(), "fSampler");       // sampler2D
 791
 792                         if (vUnif == -1 || fUnif == -1 || fSampler == -1)
 793                         {
 794                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 795                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 796                         }
 797
 798                         std::vector<GLint> data(4);
 799
 800                         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.");
 801                         glUseProgram(program.getProgram());
 802                         glUniform1iv(fUnif, 1, &data[0]);
 803                         expectError(GL_INVALID_OPERATION);
 804                         glUniform2iv(fUnif, 1, &data[0]);
 805                         expectError(GL_INVALID_OPERATION);
 806                         glUniform3iv(fUnif, 1, &data[0]);
 807                         expectError(GL_INVALID_OPERATION);
 808                         glUniform4iv(fUnif, 1, &data[0]);
 809                         expectError(GL_NO_ERROR);
 810                         m_log << tcu::TestLog::EndSection;
 811
 812                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a uniform variable of type float, vec2, vec3, or vec4.");
 813                         glUseProgram(program.getProgram());
 814                         glUniform4iv(vUnif, 1, &data[0]);
 815                         expectError(GL_INVALID_OPERATION);
 816                         m_log << tcu::TestLog::EndSection;
 817
 818                         glUseProgram(0);
 819                 });
 820         ES2F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage",
 821                 {
 822                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 823                         glUseProgram(program.getProgram());
 824
 825                         std::vector<GLint> data(4);
 826
 827                         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.");
 828                         glUseProgram(program.getProgram());
 829                         glUniform1iv(-2, 1, &data[0]);
 830                         expectError(GL_INVALID_OPERATION);
 831                         glUniform2iv(-2, 1, &data[0]);
 832                         expectError(GL_INVALID_OPERATION);
 833                         glUniform3iv(-2, 1, &data[0]);
 834                         expectError(GL_INVALID_OPERATION);
 835                         glUniform4iv(-2, 1, &data[0]);
 836                         expectError(GL_INVALID_OPERATION);
 837
 838                         glUseProgram(program.getProgram());
 839                         glUniform1iv(-1, 1, &data[0]);
 840                         expectError(GL_NO_ERROR);
 841                         glUniform2iv(-1, 1, &data[0]);
 842                         expectError(GL_NO_ERROR);
 843                         glUniform3iv(-1, 1, &data[0]);
 844                         expectError(GL_NO_ERROR);
 845                         glUniform4iv(-1, 1, &data[0]);
 846                         expectError(GL_NO_ERROR);
 847                         m_log << tcu::TestLog::EndSection;
 848
 849                         glUseProgram(0);
 850                 });
 851         ES2F_ADD_API_CASE(uniformiv_invalid_count, "Invalid glUniform{1234}iv() usage",
 852                 {
 853                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 854                         glUseProgram(program.getProgram());
 855                         GLint fUnif             = glGetUniformLocation(program.getProgram(), "fTest");          // ivec4
 856
 857                         if (fUnif == -1)
 858                         {
 859                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 860                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 861                         }
 862
 863                         std::vector<GLint> data(8);
 864
 865                         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.");
 866                         glUseProgram(program.getProgram());
 867                         glUniform1iv(fUnif, 2, &data[0]);
 868                         expectError(GL_INVALID_OPERATION);
 869                         glUniform2iv(fUnif, 2, &data[0]);
 870                         expectError(GL_INVALID_OPERATION);
 871                         glUniform3iv(fUnif, 2, &data[0]);
 872                         expectError(GL_INVALID_OPERATION);
 873                         glUniform4iv(fUnif, 2, &data[0]);
 874                         expectError(GL_INVALID_OPERATION);
 875                         m_log << tcu::TestLog::EndSection;
 876
 877                         glUseProgram(0);
 878                 });
 879
 880         // glUniformMatrix*fv
 881
 882         ES2F_ADD_API_CASE(uniform_matrixfv_invalid_program, "Invalid glUniformMatrix{234}fv() usage",
 883                 {
 884                         std::vector<GLfloat> data(16);
 885
 886                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
 887                         glUseProgram(0);
 888                         glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
 889                         expectError(GL_INVALID_OPERATION);
 890                         glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
 891                         expectError(GL_INVALID_OPERATION);
 892                         glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
 893                         expectError(GL_INVALID_OPERATION);
 894                         m_log << tcu::TestLog::EndSection;
 895                 });
 896         ES2F_ADD_API_CASE(uniform_matrixfv_incompatible_type, "Invalid glUniformMatrix{234}fv() usage",
 897                 {
 898                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 899                         glUseProgram(program.getProgram());
 900                         GLint vMatUnif          = glGetUniformLocation(program.getProgram(), "vMatrix");        // mat4
 901                         GLint fSamplerUnif      = glGetUniformLocation(program.getProgram(), "fSampler");       // sampler2D
 902
 903                         m_log << program;
 904
 905                         if (vMatUnif == -1 || fSamplerUnif == -1)
 906                         {
 907                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 908                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 909                         }
 910
 911                         std::vector<GLfloat> data(16);
 912
 913                         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.");
 914                         glUseProgram(program.getProgram());
 915                         glUniformMatrix2fv(vMatUnif, 1, GL_FALSE, &data[0]);
 916                         expectError(GL_INVALID_OPERATION);
 917                         glUniformMatrix3fv(vMatUnif, 1, GL_FALSE, &data[0]);
 918                         expectError(GL_INVALID_OPERATION);
 919                         glUniformMatrix4fv(vMatUnif, 1, GL_FALSE, &data[0]);
 920                         expectError(GL_NO_ERROR);
 921                         m_log << tcu::TestLog::EndSection;
 922
 923                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
 924                         glUseProgram(program.getProgram());
 925                         glUniformMatrix4fv(fSamplerUnif, 1, GL_FALSE, &data[0]);
 926                         expectError(GL_INVALID_OPERATION);
 927                         m_log << tcu::TestLog::EndSection;
 928
 929                         glUseProgram(0);
 930                 });
 931         ES2F_ADD_API_CASE(uniform_matrixfv_invalid_location, "Invalid glUniformMatrix{234}fv() usage",
 932                 {
 933                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 934                         glUseProgram(program.getProgram());
 935
 936                         m_log << program;
 937
 938                         std::vector<GLfloat> data(16);
 939
 940                         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.");
 941                         glUseProgram(program.getProgram());
 942                         glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
 943                         expectError(GL_INVALID_OPERATION);
 944                         glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
 945                         expectError(GL_INVALID_OPERATION);
 946                         glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
 947                         expectError(GL_INVALID_OPERATION);
 948
 949                         glUseProgram(program.getProgram());
 950                         glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
 951                         expectError(GL_NO_ERROR);
 952                         glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
 953                         expectError(GL_NO_ERROR);
 954                         glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
 955                         expectError(GL_NO_ERROR);
 956                         m_log << tcu::TestLog::EndSection;
 957
 958                         glUseProgram(0);
 959                 });
 960         ES2F_ADD_API_CASE(uniform_matrixfv_invalid_count, "Invalid glUniformMatrix{234}fv() usage",
 961                 {
 962                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 963                         glUseProgram(program.getProgram());
 964                         GLint vMatUnif          = glGetUniformLocation(program.getProgram(), "vMatrix");                // mat4
 965
 966                         m_log << program;
 967
 968                         if (vMatUnif == -1)
 969                         {
 970                                 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
 971                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 972                         }
 973
 974
 975                         std::vector<GLfloat> data(32);
 976
 977                         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.");
 978                         glUseProgram(program.getProgram());
 979                         glUniformMatrix2fv(vMatUnif, 2, GL_FALSE, &data[0]);
 980                         expectError(GL_INVALID_OPERATION);
 981                         glUniformMatrix3fv(vMatUnif, 2, GL_FALSE, &data[0]);
 982                         expectError(GL_INVALID_OPERATION);
 983                         glUniformMatrix4fv(vMatUnif, 2, GL_FALSE, &data[0]);
 984                         expectError(GL_INVALID_OPERATION);
 985                         m_log << tcu::TestLog::EndSection;
 986
 987                         glUseProgram(0);
 988                 });
 989         ES2F_ADD_API_CASE(uniform_matrixfv_invalid_transpose, "Invalid glUniformMatrix{234}fv() usage",
 990                 {
 991                         if (de::beginsWith((const char*)glGetString(GL_VERSION), "OpenGL ES 2.0 "))
 992                         {
 993                                 DE_ASSERT(m_context.getRenderContext().getType().getMajorVersion() < 3);
 994                                 DE_ASSERT(m_context.getRenderContext().getType().getMinorVersion() == 0);
 995                                 DE_ASSERT(m_context.getRenderContext().getType().getProfile() == glu::PROFILE_ES);
 996
 997                                 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 998                                 glUseProgram(program.getProgram());
 999
1000                                 m_log << program;
1001
1002                                 std::vector<GLfloat> data(16);
1003
1004                                 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if transpose is not GL_FALSE.");
1005                                 glUseProgram(program.getProgram());
1006                                 glUniformMatrix2fv(0, 1, GL_TRUE, &data[0]);
1007                                 expectError(GL_INVALID_VALUE);
1008                                 glUniformMatrix3fv(0, 1, GL_TRUE, &data[0]);
1009                                 expectError(GL_INVALID_VALUE);
1010                                 glUniformMatrix4fv(0, 1, GL_TRUE, &data[0]);
1011                                 expectError(GL_INVALID_VALUE);
1012                                 m_log << tcu::TestLog::EndSection;
1013
1014                                 glUseProgram(0);
1015                         }
1016                 });
1017 }
1018
1019 } // Functional
1020 } // gles2
1021 } // deqp