modules/gles31/functional/es31fNegativeStateApiTests.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 GL State API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fNegativeStateApiTests.hpp"
  25
  26 #include "gluCallLogWrapper.hpp"
  27 #include "gluContextInfo.hpp"
  28 #include "gluShaderProgram.hpp"
  29
  30 #include "glwDefs.hpp"
  31 #include "glwEnums.hpp"
  32
  33 #include "tcuStringTemplate.hpp"
  34
  35 #include "deMemory.h"
  36
  37 #include <string>
  38 #include <map>
  39
  40 namespace deqp
  41 {
  42 namespace gles31
  43 {
  44 namespace Functional
  45 {
  46 namespace NegativeTestShared
  47 {
  48
  49 using tcu::TestLog;
  50 using glu::CallLogWrapper;
  51 using namespace glw;
  52
  53 static const char* uniformTestVertSource        =       "${GLSL_VERSION_DECL}\n"
  54                                                                                                 "uniform mediump vec4 vUnif_vec4;\n"
  55                                                                                                 "in mediump vec4 attr;"
  56                                                                                                 "layout(shared) uniform Block { mediump vec4 blockVar; };\n"
  57                                                                                                 "void main (void)\n"
  58                                                                                                 "{\n"
  59                                                                                                 "       gl_Position = vUnif_vec4 + blockVar + attr;\n"
  60                                                                                                 "}\n\0";
  61
  62 static const char* uniformTestFragSource        =       "${GLSL_VERSION_DECL}\n"
  63                                                                                                 "uniform mediump ivec4 fUnif_ivec4;\n"
  64                                                                                                 "uniform mediump uvec4 fUnif_uvec4;\n"
  65                                                                                                 "layout(location = 0) out mediump vec4 fragColor;"
  66                                                                                                 "void main (void)\n"
  67                                                                                                 "{\n"
  68                                                                                                 "       fragColor = vec4(vec4(fUnif_ivec4) + vec4(fUnif_uvec4));\n"
  69                                                                                                 "}\n\0";
  70
  71 static std::string getVtxFragVersionSources (const std::string source, NegativeTestContext& ctx)
  72 {
  73         const bool supportsES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
  74
  75         std::map<std::string, std::string> args;
  76
  77         args["GLSL_VERSION_DECL"] = supportsES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_300_ES);
  78
  79         return tcu::StringTemplate(source).specialize(args);
  80 }
  81
  82 // Enabling & disabling states
  83 void enable (NegativeTestContext& ctx)
  84 {
  85         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
  86         ctx.glEnable(-1);
  87         ctx.expectError(GL_INVALID_ENUM);
  88         ctx.endSection();
  89 }
  90
  91 // Enabling & disabling states
  92 void enablei (NegativeTestContext& ctx)
  93 {
  94         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
  95
  96         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
  97         ctx.glEnablei(-1, -1);
  98         ctx.expectError(GL_INVALID_ENUM);
  99         ctx.endSection();
 100
 101         ctx.beginSection("GL_INVALID_VALUE is generated  if index is greater than or equal to the number of indexed capabilities for cap.");
 102         ctx.glEnablei(GL_BLEND, -1);
 103         ctx.expectError(GL_INVALID_VALUE);
 104         ctx.endSection();
 105 }
 106
 107 void disable (NegativeTestContext& ctx)
 108 {
 109         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
 110         ctx.glDisable(-1);
 111         ctx.expectError(GL_INVALID_ENUM);
 112         ctx.endSection();
 113 }
 114
 115 void disablei (NegativeTestContext& ctx)
 116 {
 117         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 118
 119         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
 120         ctx.glDisablei(-1,-1);
 121         ctx.expectError(GL_INVALID_ENUM);
 122         ctx.endSection();
 123
 124         ctx.beginSection("GL_INVALID_VALUE is generated  if index is greater than or equal to the number of indexed capabilities for cap.");
 125         ctx.glDisablei(GL_BLEND, -1);
 126         ctx.expectError(GL_INVALID_VALUE);
 127         ctx.endSection();
 128 }
 129
 130 // Simple state queries
 131 void get_booleanv (NegativeTestContext& ctx)
 132 {
 133         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 134         GLboolean params = GL_FALSE;
 135         ctx.glGetBooleanv(-1, &params);
 136         ctx.expectError(GL_INVALID_ENUM);
 137         ctx.endSection();
 138 }
 139
 140 void get_booleani_v (NegativeTestContext& ctx)
 141 {
 142         GLboolean       data                                            = -1;
 143         GLint           maxUniformBufferBindings        = 0;
 144
 145         ctx.beginSection("GL_INVALID_ENUM is generated if target is not indexed state queriable with these commands.");
 146         ctx.glGetBooleani_v(-1, 0, &data);
 147         ctx.expectError(GL_INVALID_ENUM);
 148         ctx.endSection();
 149
 150         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.");
 151         ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
 152         ctx.expectError(GL_NO_ERROR);
 153         ctx.glGetBooleani_v(GL_UNIFORM_BUFFER_BINDING, maxUniformBufferBindings, &data);
 154         ctx.expectError(GL_INVALID_VALUE);
 155         ctx.endSection();
 156 }
 157
 158 void get_floatv (NegativeTestContext& ctx)
 159 {
 160         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 161         GLfloat params = 0.0f;
 162         ctx.glGetFloatv(-1, &params);
 163         ctx.expectError(GL_INVALID_ENUM);
 164         ctx.endSection();
 165 }
 166
 167 void get_integerv (NegativeTestContext& ctx)
 168 {
 169         GLint params = -1;
 170         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 171         ctx.glGetIntegerv(-1, &params);
 172         ctx.expectError(GL_INVALID_ENUM);
 173         ctx.endSection();
 174 }
 175
 176 void get_integer64v (NegativeTestContext& ctx)
 177 {
 178         GLint64 params = -1;
 179         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 180         ctx.glGetInteger64v(-1, &params);
 181         ctx.expectError(GL_INVALID_ENUM);
 182         ctx.endSection();
 183 }
 184
 185 void get_integeri_v (NegativeTestContext& ctx)
 186 {
 187         GLint data                                                              = -1;
 188         GLint maxUniformBufferBindings                  =  0;
 189         GLint maxShaderStorageBufferBindings    =  0;
 190
 191         ctx.beginSection("GL_INVALID_ENUM is generated if name is not an accepted value.");
 192         ctx.glGetIntegeri_v(-1, 0, &data);
 193         ctx.expectError(GL_INVALID_ENUM);
 194         ctx.endSection();
 195
 196         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.");
 197         ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
 198         ctx.expectError(GL_NO_ERROR);
 199         ctx.glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, maxUniformBufferBindings, &data);
 200         ctx.expectError(GL_INVALID_VALUE);
 201         ctx.endSection();
 202
 203         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.");
 204         ctx.glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxShaderStorageBufferBindings);
 205         ctx.expectError(GL_NO_ERROR);
 206         ctx.glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, maxShaderStorageBufferBindings, &data);
 207         ctx.expectError(GL_INVALID_VALUE);
 208         ctx.endSection();
 209 }
 210
 211 void get_integer64i_v (NegativeTestContext& ctx)
 212 {
 213         GLint64 data                                                    = (GLint64)-1;
 214         GLint   maxUniformBufferBindings                = 0;
 215         GLint   maxShaderStorageBufferBindings  = 0;
 216
 217         ctx.beginSection("GL_INVALID_ENUM is generated if name is not an accepted value.");
 218         ctx.glGetInteger64i_v(-1, 0, &data);
 219         ctx.expectError(GL_INVALID_ENUM);
 220         ctx.endSection();
 221
 222         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.");
 223         ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
 224         ctx.expectError(GL_NO_ERROR);
 225         ctx.glGetInteger64i_v(GL_UNIFORM_BUFFER_START, maxUniformBufferBindings, &data);
 226         ctx.expectError(GL_INVALID_VALUE);
 227         ctx.endSection();
 228
 229         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside of the valid range for the indexed state target.");
 230         ctx.glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxShaderStorageBufferBindings);
 231         ctx.expectError(GL_NO_ERROR);
 232         ctx.glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_START, maxShaderStorageBufferBindings, &data);
 233         ctx.expectError(GL_INVALID_VALUE);
 234         ctx.glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_SIZE, maxShaderStorageBufferBindings, &data);
 235         ctx.expectError(GL_INVALID_VALUE);
 236         ctx.endSection();
 237 }
 238
 239 void get_string (NegativeTestContext& ctx)
 240 {
 241         ctx.beginSection("GL_INVALID_ENUM is generated if name is not an accepted value.");
 242         ctx.glGetString(-1);
 243         ctx.expectError(GL_INVALID_ENUM);
 244         ctx.endSection();
 245 }
 246
 247 void get_stringi (NegativeTestContext& ctx)
 248 {
 249         GLint numExtensions     = 0;
 250
 251         ctx.beginSection("GL_INVALID_ENUM is generated if name is not an accepted value.");
 252         ctx.glGetStringi(-1, 0);
 253         ctx.expectError(GL_INVALID_ENUM);
 254         ctx.endSection();
 255
 256         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside the valid range for indexed state name.");
 257         ctx.glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
 258         ctx.glGetStringi(GL_EXTENSIONS, numExtensions);
 259         ctx.expectError(GL_INVALID_VALUE);
 260         ctx.endSection();
 261 }
 262
 263 // Enumerated state queries: Shaders
 264
 265 void get_attached_shaders (NegativeTestContext& ctx)
 266 {
 267         GLuint  shaders[1]              = { 0 };
 268         GLuint  shaderObject    = ctx.glCreateShader(GL_VERTEX_SHADER);
 269         GLuint  program                 = ctx.glCreateProgram();
 270         GLsizei count[1]                = { 0 };
 271
 272         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 273         ctx.glGetAttachedShaders(-1, 1, &count[0], &shaders[0]);
 274         ctx.expectError(GL_INVALID_VALUE);
 275         ctx.endSection();
 276
 277         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 278         ctx.glGetAttachedShaders(shaderObject, 1, &count[0], &shaders[0]);
 279         ctx.expectError(GL_INVALID_OPERATION);
 280         ctx.endSection();
 281
 282         ctx.beginSection("GL_INVALID_VALUE is generated if maxCount is less than 0.");
 283         ctx.glGetAttachedShaders(program, -1, &count[0], &shaders[0]);
 284         ctx.expectError(GL_INVALID_VALUE);
 285         ctx.endSection();
 286
 287         ctx.glDeleteShader(shaderObject);
 288         ctx.glDeleteProgram(program);
 289 }
 290
 291 void get_shaderiv (NegativeTestContext& ctx)
 292 {
 293         GLboolean       shaderCompilerSupported;
 294         GLuint          shader          = ctx.glCreateShader(GL_VERTEX_SHADER);
 295         GLuint          program         = ctx.glCreateProgram();
 296         GLint           param[1]        = { -1 };
 297
 298         ctx.glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 299         ctx.getLog() << TestLog::Message << "// GL_SHADER_COMPILER = " << (shaderCompilerSupported ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 300
 301         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
 302         ctx.glGetShaderiv(shader, -1, &param[0]);
 303         ctx.expectError(GL_INVALID_ENUM);
 304         ctx.endSection();
 305
 306         ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 307         ctx.glGetShaderiv(-1, GL_SHADER_TYPE, &param[0]);
 308         ctx.expectError(GL_INVALID_VALUE);
 309         ctx.endSection();
 310
 311         ctx.beginSection("GL_INVALID_OPERATION is generated if shader does not refer to a shader object.");
 312         ctx.glGetShaderiv(program, GL_SHADER_TYPE, &param[0]);
 313         ctx.expectError(GL_INVALID_OPERATION);
 314         ctx.endSection();
 315
 316         ctx.glDeleteShader(shader);
 317         ctx.glDeleteProgram(program);
 318 }
 319
 320 void get_shader_info_log (NegativeTestContext& ctx)
 321 {
 322         GLuint shader           = ctx.glCreateShader(GL_VERTEX_SHADER);
 323         GLuint program          = ctx.glCreateProgram();
 324         GLsizei length[1]       = { -1 };
 325         char infoLog[128]       = { 0 };
 326
 327         ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 328         ctx.glGetShaderInfoLog(-1, 128, &length[0], &infoLog[0]);
 329         ctx.expectError(GL_INVALID_VALUE);
 330         ctx.endSection();
 331
 332         ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
 333         ctx.glGetShaderInfoLog(program, 128, &length[0], &infoLog[0]);
 334         ctx.expectError(GL_INVALID_OPERATION);
 335         ctx.endSection();
 336
 337         ctx.beginSection("GL_INVALID_VALUE is generated if maxLength is less than 0.");
 338         ctx.glGetShaderInfoLog(shader, -1, &length[0], &infoLog[0]);
 339         ctx.expectError(GL_INVALID_VALUE);
 340         ctx.endSection();
 341
 342         ctx.glDeleteShader(shader);
 343         ctx.glDeleteProgram(program);
 344 }
 345
 346 void get_shader_precision_format (NegativeTestContext& ctx)
 347 {
 348         GLboolean       shaderCompilerSupported;
 349         GLint           range[2];
 350         GLint           precision[1];
 351
 352         ctx.glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 353         ctx.getLog() << TestLog::Message << "// GL_SHADER_COMPILER = " << (shaderCompilerSupported ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 354
 355         deMemset(&range[0], 0xcd, sizeof(range));
 356         deMemset(&precision[0], 0xcd, sizeof(precision));
 357
 358         ctx.beginSection("GL_INVALID_ENUM is generated if shaderType or precisionType is not an accepted value.");
 359         ctx.glGetShaderPrecisionFormat (-1, GL_MEDIUM_FLOAT, &range[0], &precision[0]);
 360         ctx.expectError(GL_INVALID_ENUM);
 361         ctx.glGetShaderPrecisionFormat (GL_VERTEX_SHADER, -1, &range[0], &precision[0]);
 362         ctx.expectError(GL_INVALID_ENUM);
 363         ctx.glGetShaderPrecisionFormat (-1, -1, &range[0], &precision[0]);
 364         ctx.expectError(GL_INVALID_ENUM);
 365         ctx.endSection();
 366 }
 367
 368 void get_shader_source (NegativeTestContext& ctx)
 369 {
 370         GLsizei length[1]       = { 0 };
 371         char    source[1]       = { 0 };
 372         GLuint  program         = ctx.glCreateProgram();
 373         GLuint  shader          = ctx.glCreateShader(GL_VERTEX_SHADER);
 374
 375         ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 376         ctx.glGetShaderSource(-1, 1, &length[0], &source[0]);
 377         ctx.expectError(GL_INVALID_VALUE);
 378         ctx.endSection();
 379
 380         ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
 381         ctx.glGetShaderSource(program, 1, &length[0], &source[0]);
 382         ctx.expectError(GL_INVALID_OPERATION);
 383         ctx.endSection();
 384
 385         ctx.beginSection("GL_INVALID_VALUE is generated if bufSize is less than 0.");
 386         ctx.glGetShaderSource(shader, -1, &length[0], &source[0]);
 387         ctx.expectError(GL_INVALID_VALUE);
 388         ctx.endSection();
 389
 390         ctx.glDeleteProgram(program);
 391         ctx.glDeleteShader(shader);
 392 }
 393
 394 // Enumerated state queries: Programs
 395
 396 void get_programiv (NegativeTestContext& ctx)
 397 {
 398         GLuint  program         = ctx.glCreateProgram();
 399         GLuint  shader          = ctx.glCreateShader(GL_VERTEX_SHADER);
 400         GLint   params[1]       = { 0 };
 401
 402         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
 403         ctx.glGetProgramiv(program, -1, &params[0]);
 404         ctx.expectError(GL_INVALID_ENUM);
 405         ctx.endSection();
 406
 407         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 408         ctx.glGetProgramiv(-1, GL_LINK_STATUS, &params[0]);
 409         ctx.expectError(GL_INVALID_VALUE);
 410         ctx.endSection();
 411
 412         ctx.beginSection("GL_INVALID_OPERATION is generated if program does not refer to a program object.");
 413         ctx.glGetProgramiv(shader, GL_LINK_STATUS, &params[0]);
 414         ctx.expectError(GL_INVALID_OPERATION);
 415         ctx.endSection();
 416
 417         ctx.glDeleteProgram(program);
 418         ctx.glDeleteShader(shader);
 419 }
 420
 421 void get_program_info_log (NegativeTestContext& ctx)
 422 {
 423         GLuint  program         = ctx.glCreateProgram();
 424         GLuint  shader          = ctx.glCreateShader(GL_VERTEX_SHADER);
 425         GLsizei length[1]       = { 0 };
 426         char    infoLog[1]      = { 'x' };
 427
 428         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 429         ctx.glGetProgramInfoLog (-1, 1, &length[0], &infoLog[0]);
 430         ctx.expectError(GL_INVALID_VALUE);
 431         ctx.endSection();
 432
 433         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 434         ctx.glGetProgramInfoLog (shader, 1, &length[0], &infoLog[0]);
 435         ctx.expectError(GL_INVALID_OPERATION);
 436         ctx.endSection();
 437
 438         ctx.beginSection("GL_INVALID_VALUE is generated if maxLength is less than 0.");
 439         ctx.glGetProgramInfoLog (program, -1, &length[0], &infoLog[0]);
 440         ctx.expectError(GL_INVALID_VALUE);
 441         ctx.endSection();
 442
 443         ctx.glDeleteProgram(program);
 444         ctx.glDeleteShader(shader);
 445 }
 446
 447 // Enumerated state queries: Shader variables
 448
 449 void get_tex_parameterfv (NegativeTestContext& ctx)
 450 {
 451         GLfloat params[1] = { 0 };
 452
 453         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 454         ctx.glGetTexParameterfv (-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 455         ctx.expectError(GL_INVALID_ENUM);
 456         ctx.glGetTexParameterfv (GL_TEXTURE_2D, -1, &params[0]);
 457         ctx.expectError(GL_INVALID_ENUM);
 458         ctx.glGetTexParameterfv (-1, -1, &params[0]);
 459         ctx.expectError(GL_INVALID_ENUM);
 460         ctx.endSection();
 461 }
 462
 463 void get_tex_parameteriv (NegativeTestContext& ctx)
 464 {
 465         GLint params[1] = { 0 };
 466
 467         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 468         ctx.glGetTexParameteriv (-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 469         ctx.expectError(GL_INVALID_ENUM);
 470         ctx.glGetTexParameteriv (GL_TEXTURE_2D, -1, &params[0]);
 471         ctx.expectError(GL_INVALID_ENUM);
 472         ctx.glGetTexParameteriv (-1, -1, &params[0]);
 473         ctx.expectError(GL_INVALID_ENUM);
 474         ctx.endSection();
 475 }
 476
 477 void get_tex_parameteriiv (NegativeTestContext& ctx)
 478 {
 479         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 480
 481         GLint params[1] = { 0 };
 482
 483         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 484         ctx.glGetTexParameterIiv(-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 485         ctx.expectError(GL_INVALID_ENUM);
 486         ctx.glGetTexParameterIiv(GL_TEXTURE_2D, -1, &params[0]);
 487         ctx.expectError(GL_INVALID_ENUM);
 488         ctx.glGetTexParameterIiv(-1, -1, &params[0]);
 489         ctx.expectError(GL_INVALID_ENUM);
 490         ctx.endSection();
 491 }
 492
 493 void get_tex_parameteriuiv (NegativeTestContext& ctx)
 494 {
 495         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 496
 497         GLuint params[1] = { 0 };
 498
 499         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 500         ctx.glGetTexParameterIuiv(-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 501         ctx.expectError(GL_INVALID_ENUM);
 502         ctx.glGetTexParameterIuiv(GL_TEXTURE_2D, -1, &params[0]);
 503         ctx.expectError(GL_INVALID_ENUM);
 504         ctx.glGetTexParameterIuiv(-1, -1, &params[0]);
 505         ctx.expectError(GL_INVALID_ENUM);
 506         ctx.endSection();
 507 }
 508
 509 void get_uniformfv (NegativeTestContext& ctx)
 510 {
 511         glu::ShaderProgram      program         (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 512         GLfloat                         params[4]       = { 0.f };
 513         GLuint                          shader;
 514         GLuint                          programEmpty;
 515         GLint                           unif;
 516
 517         ctx.glUseProgram(program.getProgram());
 518
 519         unif = ctx.glGetUniformLocation(program.getProgram(), "vUnif_vec4");    // vec4
 520         if (unif == -1)
 521                 ctx.fail("Failed to retrieve uniform location");
 522
 523         shader = ctx.glCreateShader(GL_VERTEX_SHADER);
 524         programEmpty = ctx.glCreateProgram();
 525
 526         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 527         ctx.glGetUniformfv (-1, unif, &params[0]);
 528         ctx.expectError(GL_INVALID_VALUE);
 529         ctx.endSection();
 530
 531         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 532         ctx.glGetUniformfv (shader, unif, &params[0]);
 533         ctx.expectError(GL_INVALID_OPERATION);
 534         ctx.endSection();
 535
 536         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 537         ctx.glGetUniformfv (programEmpty, unif, &params[0]);
 538         ctx.expectError(GL_INVALID_OPERATION);
 539         ctx.endSection();
 540
 541         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 542         ctx.glGetUniformfv (program.getProgram(), -1, &params[0]);
 543         ctx.expectError(GL_INVALID_OPERATION);
 544         ctx.endSection();
 545
 546         ctx.glDeleteShader(shader);
 547         ctx.glDeleteProgram(programEmpty);
 548 }
 549
 550 void get_nuniformfv (NegativeTestContext& ctx)
 551 {
 552         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 553
 554         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 555         GLint                           unif                    = ctx.glGetUniformLocation(program.getProgram(), "vUnif_vec4");
 556         GLfloat                         params[4]               = { 0.0f, 0.0f, 0.0f, 0.0f };
 557         GLuint                          shader;
 558         GLuint                          programEmpty;
 559         GLsizei                         bufferSize;
 560
 561         ctx.glUseProgram(program.getProgram());
 562
 563         if (unif == -1)
 564                 ctx.fail("Failed to retrieve uniform location");
 565
 566         shader                  = ctx.glCreateShader(GL_VERTEX_SHADER);
 567         programEmpty    = ctx.glCreateProgram();
 568
 569         ctx.glGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS, &bufferSize);
 570
 571         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 572         ctx.glGetnUniformfv(-1, unif, bufferSize, &params[0]);
 573         ctx.expectError(GL_INVALID_VALUE);
 574         ctx.endSection();
 575
 576         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 577         ctx.glGetnUniformfv(shader, unif, bufferSize, &params[0]);
 578         ctx.expectError(GL_INVALID_OPERATION);
 579         ctx.endSection();
 580
 581         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 582         ctx.glGetnUniformfv(programEmpty, unif, bufferSize, &params[0]);
 583         ctx.expectError(GL_INVALID_OPERATION);
 584         ctx.endSection();
 585
 586         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 587         ctx.glGetnUniformfv(program.getProgram(), -1, bufferSize, &params[0]);
 588         ctx.expectError(GL_INVALID_OPERATION);
 589         ctx.endSection();
 590
 591         ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer size required to store the requested data is greater than bufSize.");
 592         ctx.glGetnUniformfv(program.getProgram(), unif, 0, &params[0]);
 593         ctx.expectError(GL_INVALID_OPERATION);
 594         ctx.endSection();
 595
 596         ctx.glDeleteShader(shader);
 597         ctx.glDeleteProgram(programEmpty);
 598 }
 599
 600 void get_uniformiv (NegativeTestContext& ctx)
 601 {
 602         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 603         GLint                           unif                    = ctx.glGetUniformLocation(program.getProgram(), "fUnif_ivec4");
 604         GLint                           params[4]               = { 0, 0, 0, 0 };
 605         GLuint                          shader;
 606         GLuint                          programEmpty;
 607
 608         ctx.glUseProgram(program.getProgram());
 609
 610         if (unif == -1)
 611                 ctx.fail("Failed to retrieve uniform location");
 612
 613         shader = ctx.glCreateShader(GL_VERTEX_SHADER);
 614         programEmpty = ctx.glCreateProgram();
 615
 616         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 617         ctx.glGetUniformiv (-1, unif, &params[0]);
 618         ctx.expectError(GL_INVALID_VALUE);
 619         ctx.endSection();
 620
 621         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 622         ctx.glGetUniformiv (shader, unif, &params[0]);
 623         ctx.expectError(GL_INVALID_OPERATION);
 624         ctx.endSection();
 625
 626         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 627         ctx.glGetUniformiv (programEmpty, unif, &params[0]);
 628         ctx.expectError(GL_INVALID_OPERATION);
 629         ctx.endSection();
 630
 631         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 632         ctx.glGetUniformiv (program.getProgram(), -1, &params[0]);
 633         ctx.expectError(GL_INVALID_OPERATION);
 634         ctx.endSection();
 635
 636         ctx.glDeleteShader(shader);
 637         ctx.glDeleteProgram(programEmpty);
 638 }
 639
 640 void get_nuniformiv (NegativeTestContext& ctx)
 641 {
 642         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 643
 644         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 645         GLint                           unif                    = ctx.glGetUniformLocation(program.getProgram(), "fUnif_ivec4");
 646         GLint                           params[4]               = { 0, 0, 0, 0 };
 647         GLuint                          shader;
 648         GLuint                          programEmpty;
 649         GLsizei                         bufferSize;
 650
 651         ctx.glUseProgram(program.getProgram());
 652
 653         if (unif == -1)
 654                 ctx.fail("Failed to retrieve uniform location");
 655
 656         shader = ctx.glCreateShader(GL_VERTEX_SHADER);
 657         programEmpty = ctx.glCreateProgram();
 658
 659         ctx.glGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS, &bufferSize);
 660
 661         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 662         ctx.glGetnUniformiv(-1, unif, bufferSize, &params[0]);
 663         ctx.expectError(GL_INVALID_VALUE);
 664         ctx.endSection();
 665
 666         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 667         ctx.glGetnUniformiv(shader, unif, bufferSize, &params[0]);
 668         ctx.expectError(GL_INVALID_OPERATION);
 669         ctx.endSection();
 670
 671         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 672         ctx.glGetnUniformiv(programEmpty, unif, bufferSize, &params[0]);
 673         ctx.expectError(GL_INVALID_OPERATION);
 674         ctx.endSection();
 675
 676         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 677         ctx.glGetnUniformiv(program.getProgram(), -1, bufferSize, &params[0]);
 678         ctx.expectError(GL_INVALID_OPERATION);
 679         ctx.endSection();
 680
 681         ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer size required to store the requested data is greater than bufSize.");
 682         ctx.glGetnUniformiv(program.getProgram(), unif, - 1, &params[0]);
 683         ctx.expectError(GL_INVALID_OPERATION);
 684         ctx.endSection();
 685
 686         ctx.glDeleteShader(shader);
 687         ctx.glDeleteProgram(programEmpty);
 688 }
 689
 690 void get_uniformuiv (NegativeTestContext& ctx)
 691 {
 692         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 693         GLint                           unif                    = ctx.glGetUniformLocation(program.getProgram(), "fUnif_uvec4");
 694         GLuint                          params[4]               = { 0, 0, 0, 0 };
 695         GLuint                          shader;
 696         GLuint                          programEmpty;
 697
 698         ctx.glUseProgram(program.getProgram());
 699
 700         if (unif == -1)
 701                 ctx.fail("Failed to retrieve uniform location");
 702
 703         shader = ctx.glCreateShader(GL_VERTEX_SHADER);
 704         programEmpty = ctx.glCreateProgram();
 705
 706         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 707         ctx.glGetUniformuiv (-1, unif, &params[0]);
 708         ctx.expectError(GL_INVALID_VALUE);
 709         ctx.endSection();
 710
 711         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 712         ctx.glGetUniformuiv (shader, unif, &params[0]);
 713         ctx.expectError(GL_INVALID_OPERATION);
 714         ctx.endSection();
 715
 716         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 717         ctx.glGetUniformuiv (programEmpty, unif, &params[0]);
 718         ctx.expectError(GL_INVALID_OPERATION);
 719         ctx.endSection();
 720
 721         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 722         ctx.glGetUniformuiv (program.getProgram(), -1, &params[0]);
 723         ctx.expectError(GL_INVALID_OPERATION);
 724         ctx.endSection();
 725
 726         ctx.glDeleteShader(shader);
 727         ctx.glDeleteProgram(programEmpty);
 728 }
 729
 730 void get_nuniformuiv (NegativeTestContext& ctx)
 731 {
 732         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
 733
 734         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 735         GLint                           unif                    = ctx.glGetUniformLocation(program.getProgram(), "fUnif_ivec4");
 736         GLuint                          params[4]               = { 0, 0, 0, 0 };
 737         GLuint                          shader;
 738         GLuint                          programEmpty;
 739         GLsizei                         bufferSize;
 740
 741         ctx.glUseProgram(program.getProgram());
 742
 743         if (unif == -1)
 744                 ctx.fail("Failed to retrieve uniform location");
 745
 746         shader = ctx.glCreateShader(GL_VERTEX_SHADER);
 747         programEmpty = ctx.glCreateProgram();
 748
 749         ctx.glGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS, &bufferSize);
 750
 751         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 752         ctx.glGetnUniformuiv(-1, unif, bufferSize, &params[0]);
 753         ctx.expectError(GL_INVALID_VALUE);
 754         ctx.endSection();
 755
 756         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 757         ctx.glGetnUniformuiv(shader, unif, bufferSize, &params[0]);
 758         ctx.expectError(GL_INVALID_OPERATION);
 759         ctx.endSection();
 760
 761         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 762         ctx.glGetnUniformuiv(programEmpty, unif, bufferSize, &params[0]);
 763         ctx.expectError(GL_INVALID_OPERATION);
 764         ctx.endSection();
 765
 766         ctx.beginSection("GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 767         ctx.glGetnUniformuiv(program.getProgram(), -1, bufferSize, &params[0]);
 768         ctx.expectError(GL_INVALID_OPERATION);
 769         ctx.endSection();
 770
 771         ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer size required to store the requested data is greater than bufSize.");
 772         ctx.glGetnUniformuiv(program.getProgram(), unif, -1, &params[0]);
 773         ctx.expectError(GL_INVALID_OPERATION);
 774         ctx.endSection();
 775
 776         ctx.glDeleteShader(shader);
 777         ctx.glDeleteProgram(programEmpty);
 778 }
 779
 780 void get_active_uniform (NegativeTestContext& ctx)
 781 {
 782         GLuint                          shader                          = ctx.glCreateShader(GL_VERTEX_SHADER);
 783         glu::ShaderProgram      program                         (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 784         GLint                           numActiveUniforms       = -1;
 785
 786         ctx.glGetProgramiv      (program.getProgram(), GL_ACTIVE_UNIFORMS,      &numActiveUniforms);
 787         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << " (expected 4)." << TestLog::EndMessage;
 788
 789         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 790         ctx.glGetActiveUniform(-1, 0, 0, 0, 0, 0, 0);
 791         ctx.expectError(GL_INVALID_VALUE);
 792         ctx.endSection();
 793
 794         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 795         ctx.glGetActiveUniform(shader, 0, 0, 0, 0, 0, 0);
 796         ctx.expectError(GL_INVALID_OPERATION);
 797         ctx.endSection();
 798
 799         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to the number of active uniform variables in program.");
 800         ctx.glUseProgram(program.getProgram());
 801         ctx.glGetActiveUniform(program.getProgram(), numActiveUniforms, 0, 0, 0, 0, 0);
 802         ctx.expectError(GL_INVALID_VALUE);
 803         ctx.endSection();
 804
 805         ctx.beginSection("GL_INVALID_VALUE is generated if bufSize is less than 0.");
 806         ctx.glGetActiveUniform(program.getProgram(), 0, -1, 0, 0, 0, 0);
 807         ctx.expectError(GL_INVALID_VALUE);
 808         ctx.endSection();
 809
 810         ctx.glUseProgram(0);
 811         ctx.glDeleteShader(shader);
 812 }
 813
 814 void get_active_uniformsiv (NegativeTestContext& ctx)
 815 {
 816         GLuint                                  shader                          = ctx.glCreateShader(GL_VERTEX_SHADER);
 817         glu::ShaderProgram              program                         (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 818         GLuint                                  dummyUniformIndex       = 1;
 819         GLint                                   dummyParamDst           = -1;
 820         GLint                                   numActiveUniforms       = -1;
 821
 822         ctx.glUseProgram(program.getProgram());
 823
 824         ctx.glGetProgramiv      (program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
 825         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << " (expected 4)." << TestLog::EndMessage;
 826
 827         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 828         ctx.glGetActiveUniformsiv(-1, 1, &dummyUniformIndex, GL_UNIFORM_TYPE, &dummyParamDst);
 829         ctx.expectError(GL_INVALID_VALUE);
 830         ctx.endSection();
 831
 832         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 833         ctx.glGetActiveUniformsiv(shader, 1, &dummyUniformIndex, GL_UNIFORM_TYPE, &dummyParamDst);
 834         ctx.expectError(GL_INVALID_OPERATION);
 835         ctx.endSection();
 836
 837         ctx.beginSection("GL_INVALID_VALUE is generated if any value in uniformIndices is greater than or equal to the value of GL_ACTIVE_UNIFORMS for program.");
 838         for (int excess = 0; excess <= 2; excess++)
 839         {
 840                 std::vector<GLuint> invalidUniformIndices;
 841                 invalidUniformIndices.push_back(1);
 842                 invalidUniformIndices.push_back(numActiveUniforms-1+excess);
 843                 invalidUniformIndices.push_back(1);
 844
 845                 std::vector<GLint> dummyParamsDst(invalidUniformIndices.size());
 846                 ctx.glGetActiveUniformsiv(program.getProgram(), (GLsizei)invalidUniformIndices.size(), &invalidUniformIndices[0], GL_UNIFORM_TYPE, &dummyParamsDst[0]);
 847                 ctx.expectError(excess == 0 ? GL_NO_ERROR : GL_INVALID_VALUE);
 848         }
 849         ctx.endSection();
 850
 851         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted token.");
 852         ctx.glGetActiveUniformsiv(program.getProgram(), 1, &dummyUniformIndex, -1, &dummyParamDst);
 853         ctx.expectError(GL_INVALID_ENUM);
 854         ctx.endSection();
 855
 856         ctx.glUseProgram(0);
 857         ctx.glDeleteShader(shader);
 858 }
 859
 860 void get_active_uniform_blockiv (NegativeTestContext& ctx)
 861 {
 862         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 863         GLuint                          shader                  = ctx.glCreateShader(GL_VERTEX_SHADER);
 864         GLint                           params                  = -1;
 865         GLint                           numActiveBlocks = -1;
 866
 867         ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
 868         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << " (expected 1)." << TestLog::EndMessage;
 869         ctx.expectError(GL_NO_ERROR);
 870
 871         ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of either a program or shader object.");
 872         ctx.glGetActiveUniformBlockiv(-1, 0, GL_UNIFORM_BLOCK_BINDING, &params);
 873         ctx.expectError(GL_INVALID_VALUE);
 874         ctx.endSection();
 875
 876         ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object");
 877         ctx.glGetActiveUniformBlockiv(shader, 0, GL_UNIFORM_BLOCK_BINDING, &params);
 878         ctx.expectError(GL_INVALID_OPERATION);
 879         ctx.endSection();
 880
 881         ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockIndex is greater than or equal to the value of GL_ACTIVE_UNIFORM_BLOCKS or is not the index of an active uniform block in program.");
 882         ctx.glUseProgram(program.getProgram());
 883         ctx.expectError(GL_NO_ERROR);
 884         ctx.glGetActiveUniformBlockiv(program.getProgram(), numActiveBlocks, GL_UNIFORM_BLOCK_BINDING, &params);
 885         ctx.expectError(GL_INVALID_VALUE);
 886         ctx.endSection();
 887
 888         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the accepted tokens.");
 889         ctx.glGetActiveUniformBlockiv(program.getProgram(), 0, -1, &params);
 890         ctx.expectError(GL_INVALID_ENUM);
 891         ctx.endSection();
 892
 893         ctx.glUseProgram(0);
 894 }
 895
 896 void get_active_uniform_block_name (NegativeTestContext& ctx)
 897 {
 898         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 899         GLuint                          shader                  = ctx.glCreateShader(GL_VERTEX_SHADER);
 900         GLsizei                         length                  = -1;
 901         GLint                           numActiveBlocks = -1;
 902         GLchar                          uniformBlockName[128];
 903
 904         deMemset(&uniformBlockName[0], 0, sizeof(uniformBlockName));
 905
 906         ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
 907         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << " (expected 1)." << TestLog::EndMessage;
 908         ctx.expectError(GL_NO_ERROR);
 909
 910         ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
 911         ctx.glGetActiveUniformBlockName(shader, numActiveBlocks, GL_UNIFORM_BLOCK_BINDING, &length, &uniformBlockName[0]);
 912         ctx.expectError(GL_INVALID_OPERATION);
 913         ctx.endSection();
 914
 915         ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of either a program or shader object.");
 916         ctx.glGetActiveUniformBlockName(-1, numActiveBlocks, GL_UNIFORM_BLOCK_BINDING, &length, &uniformBlockName[0]);
 917         ctx.expectError(GL_INVALID_VALUE);
 918         ctx.endSection();
 919
 920         ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockIndex is greater than or equal to the value of GL_ACTIVE_UNIFORM_BLOCKS or is not the index of an active uniform block in program.");
 921         ctx.glUseProgram(program.getProgram());
 922         ctx.expectError(GL_NO_ERROR);
 923         ctx.glGetActiveUniformBlockName(program.getProgram(), numActiveBlocks, (int)sizeof(uniformBlockName), &length, &uniformBlockName[0]);
 924         ctx.expectError(GL_INVALID_VALUE);
 925         ctx.endSection();
 926
 927         ctx.glUseProgram(0);
 928 }
 929
 930 void get_active_attrib (NegativeTestContext& ctx)
 931 {
 932         GLuint                          shader                          = ctx.glCreateShader(GL_VERTEX_SHADER);
 933         glu::ShaderProgram      program                         (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 934         GLint                           numActiveAttributes     = -1;
 935         GLsizei                         length                          = -1;
 936         GLint                           size                            = -1;
 937         GLenum                          type                            = -1;
 938         GLchar                          name[32];
 939
 940         deMemset(&name[0], 0, sizeof(name));
 941
 942         ctx.glGetProgramiv      (program.getProgram(), GL_ACTIVE_ATTRIBUTES,    &numActiveAttributes);
 943         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_ATTRIBUTES = " << numActiveAttributes << " (expected 1)." << TestLog::EndMessage;
 944
 945         ctx.glUseProgram(program.getProgram());
 946
 947         ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 948         ctx.glGetActiveAttrib(-1, 0, 32, &length, &size, &type, &name[0]);
 949         ctx.expectError(GL_INVALID_VALUE);
 950         ctx.endSection();
 951
 952         ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
 953         ctx.glGetActiveAttrib(shader, 0, 32, &length, &size, &type, &name[0]);
 954         ctx.expectError(GL_INVALID_OPERATION);
 955         ctx.endSection();
 956
 957         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_ACTIVE_ATTRIBUTES.");
 958         ctx.glGetActiveAttrib(program.getProgram(), numActiveAttributes, (int)sizeof(name), &length, &size, &type, &name[0]);
 959         ctx.expectError(GL_INVALID_VALUE);
 960         ctx.endSection();
 961
 962         ctx.beginSection("GL_INVALID_VALUE is generated if bufSize is less than 0.");
 963         ctx.glGetActiveAttrib(program.getProgram(), 0, -1, &length, &size, &type, &name[0]);
 964         ctx.expectError(GL_INVALID_VALUE);
 965         ctx.endSection();
 966
 967         ctx.glUseProgram(0);
 968         ctx.glDeleteShader(shader);
 969 }
 970
 971 void get_uniform_indices (NegativeTestContext& ctx)
 972 {
 973         GLuint                          shader                  = ctx.glCreateShader(GL_VERTEX_SHADER);
 974         glu::ShaderProgram      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(getVtxFragVersionSources(uniformTestVertSource, ctx), getVtxFragVersionSources(uniformTestFragSource, ctx)));
 975         GLint                           numActiveBlocks = -1;
 976         const GLchar*           uniformName             = "Block.blockVar";
 977         GLuint                          uniformIndices  = -1;
 978         GLuint                          invalid                 = -1;
 979
 980         ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS,      &numActiveBlocks);
 981         ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = "            << numActiveBlocks                      << TestLog::EndMessage;
 982         ctx.expectError(GL_NO_ERROR);
 983
 984         ctx.beginSection("GL_INVALID_OPERATION is generated if program is a name of shader object.");
 985         ctx.glGetUniformIndices(shader, 1, &uniformName, &uniformIndices);
 986         ctx.expectError(GL_INVALID_OPERATION);
 987         ctx.endSection();
 988
 989         ctx.beginSection("GL_INVALID_VALUE is generated if program is not name of program or shader object.");
 990         ctx.glGetUniformIndices(invalid, 1, &uniformName, &uniformIndices);
 991         ctx.expectError(GL_INVALID_VALUE);
 992         ctx.endSection();
 993
 994         ctx.glUseProgram(0);
 995         ctx.glDeleteShader(shader);
 996 }
 997
 998 void get_vertex_attribfv (NegativeTestContext& ctx)
 999 {
1000         GLfloat params                          = 0.0f;
1001         GLint   maxVertexAttribs;
1002
1003         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1004         ctx.glGetVertexAttribfv(0, -1, &params);
1005         ctx.expectError(GL_INVALID_ENUM);
1006         ctx.endSection();
1007
1008         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
1009         ctx.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
1010         ctx.glGetVertexAttribfv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params);
1011         ctx.expectError(GL_INVALID_VALUE);
1012         ctx.endSection();
1013 }
1014
1015 void get_vertex_attribiv (NegativeTestContext& ctx)
1016 {
1017         GLint   params                          = -1;
1018         GLint   maxVertexAttribs;
1019
1020         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1021         ctx.glGetVertexAttribiv(0, -1, &params);
1022         ctx.expectError(GL_INVALID_ENUM);
1023         ctx.endSection();
1024
1025         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
1026         ctx.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
1027         ctx.glGetVertexAttribiv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params);
1028         ctx.expectError(GL_INVALID_VALUE);
1029         ctx.endSection();
1030 }
1031
1032 void get_vertex_attribi_iv (NegativeTestContext& ctx)
1033 {
1034         GLint   params                          = -1;
1035         GLint   maxVertexAttribs;
1036
1037         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1038         ctx.glGetVertexAttribIiv(0, -1, &params);
1039         ctx.expectError(GL_INVALID_ENUM);
1040         ctx.endSection();
1041
1042         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
1043         ctx.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
1044         ctx.glGetVertexAttribIiv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params);
1045         ctx.expectError(GL_INVALID_VALUE);
1046         ctx.endSection();
1047 }
1048
1049 void get_vertex_attribi_uiv (NegativeTestContext& ctx)
1050 {
1051         GLuint  params                          = (GLuint)-1;
1052         GLint   maxVertexAttribs;
1053
1054         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1055         ctx.glGetVertexAttribIuiv(0, -1, &params);
1056         ctx.expectError(GL_INVALID_ENUM);
1057         ctx.endSection();
1058
1059         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
1060         ctx.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
1061         ctx.glGetVertexAttribIuiv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params);
1062         ctx.expectError(GL_INVALID_VALUE);
1063         ctx.endSection();
1064 }
1065
1066 void get_vertex_attrib_pointerv (NegativeTestContext& ctx)
1067 {
1068         GLvoid* ptr[1]                          = { DE_NULL };
1069         GLint   maxVertexAttribs;
1070
1071         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1072         ctx.glGetVertexAttribPointerv(0, -1, &ptr[0]);
1073         ctx.expectError(GL_INVALID_ENUM);
1074         ctx.endSection();
1075
1076         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
1077         ctx.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
1078         ctx.glGetVertexAttribPointerv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr[0]);
1079         ctx.expectError(GL_INVALID_VALUE);
1080         ctx.endSection();
1081 }
1082
1083 void get_frag_data_location (NegativeTestContext& ctx)
1084 {
1085         GLuint shader   = ctx.glCreateShader(GL_VERTEX_SHADER);
1086         GLuint program  = ctx.glCreateProgram();
1087
1088         ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
1089         ctx.glGetFragDataLocation(shader, "gl_FragColor");
1090         ctx.expectError(GL_INVALID_OPERATION);
1091         ctx.endSection();
1092
1093         ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been linked.");
1094         ctx.glGetFragDataLocation(program, "gl_FragColor");
1095         ctx.expectError(GL_INVALID_OPERATION);
1096         ctx.endSection();
1097
1098         ctx.glDeleteProgram(program);
1099         ctx.glDeleteShader(shader);
1100 }
1101
1102 // Enumerated state queries: Buffers
1103
1104 void get_buffer_parameteriv (NegativeTestContext& ctx)
1105 {
1106         GLint   params  = -1;
1107         GLuint  buf;
1108         ctx.glGenBuffers(1, &buf);
1109         ctx.glBindBuffer(GL_ARRAY_BUFFER, buf);
1110
1111         ctx.beginSection("GL_INVALID_ENUM is generated if target or value is not an accepted value.");
1112         ctx.glGetBufferParameteriv(-1, GL_BUFFER_SIZE, &params);
1113         ctx.expectError(GL_INVALID_ENUM);
1114         ctx.glGetBufferParameteriv(GL_ARRAY_BUFFER, -1, &params);
1115         ctx.expectError(GL_INVALID_ENUM);
1116         ctx.glGetBufferParameteriv(-1, -1, &params);
1117         ctx.expectError(GL_INVALID_ENUM);
1118         ctx.endSection();
1119
1120         ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
1121         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
1122         ctx.glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &params);
1123         ctx.expectError(GL_INVALID_OPERATION);
1124         ctx.endSection();
1125
1126         ctx.glDeleteBuffers(1, &buf);
1127 }
1128
1129 void get_buffer_parameteri64v (NegativeTestContext& ctx)
1130 {
1131         GLint64 params  = -1;
1132         GLuint  buf;
1133         ctx.glGenBuffers(1, &buf);
1134         ctx.glBindBuffer(GL_ARRAY_BUFFER, buf);
1135
1136         ctx.beginSection("GL_INVALID_ENUM is generated if target or value is not an accepted value.");
1137         ctx.glGetBufferParameteri64v(-1, GL_BUFFER_SIZE, &params);
1138         ctx.expectError(GL_INVALID_ENUM);
1139         ctx.glGetBufferParameteri64v(GL_ARRAY_BUFFER , -1, &params);
1140         ctx.expectError(GL_INVALID_ENUM);
1141         ctx.glGetBufferParameteri64v(-1, -1, &params);
1142         ctx.expectError(GL_INVALID_ENUM);
1143         ctx.endSection();
1144
1145         ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
1146         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
1147         ctx.glGetBufferParameteri64v(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &params);
1148         ctx.expectError(GL_INVALID_OPERATION);
1149         ctx.endSection();
1150
1151         ctx.glDeleteBuffers(1, &buf);
1152 }
1153
1154 void get_buffer_pointerv (NegativeTestContext& ctx)
1155 {
1156         GLvoid* params  = DE_NULL;
1157         GLuint  buf;
1158         ctx.glGenBuffers(1, &buf);
1159         ctx.glBindBuffer(GL_ARRAY_BUFFER, buf);
1160
1161         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
1162         ctx.glGetBufferPointerv(GL_ARRAY_BUFFER, -1, &params);
1163         ctx.expectError(GL_INVALID_ENUM);
1164         ctx.glGetBufferPointerv(-1, GL_BUFFER_MAP_POINTER, &params);
1165         ctx.expectError(GL_INVALID_ENUM);
1166         ctx.endSection();
1167
1168         ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
1169         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
1170         ctx.glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &params);
1171         ctx.expectError(GL_INVALID_OPERATION);
1172         ctx.endSection();
1173
1174         ctx.glDeleteBuffers(1, &buf);
1175 }
1176
1177 void get_framebuffer_attachment_parameteriv (NegativeTestContext& ctx)
1178 {
1179         GLint   params[1]       = { -1 };
1180         GLuint  fbo;
1181         GLuint  rbo[2];
1182
1183         ctx.glGenFramebuffers                   (1, &fbo);
1184         ctx.glGenRenderbuffers                  (2, rbo);
1185
1186         ctx.glBindFramebuffer                   (GL_FRAMEBUFFER,        fbo);
1187         ctx.glBindRenderbuffer                  (GL_RENDERBUFFER,       rbo[0]);
1188         ctx.glRenderbufferStorage               (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 16, 16);
1189         ctx.glFramebufferRenderbuffer   (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbo[0]);
1190         ctx.glBindRenderbuffer                  (GL_RENDERBUFFER,       rbo[1]);
1191         ctx.glRenderbufferStorage               (GL_RENDERBUFFER, GL_STENCIL_INDEX8, 16, 16);
1192         ctx.glFramebufferRenderbuffer   (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[1]);
1193         ctx.glCheckFramebufferStatus    (GL_FRAMEBUFFER);
1194         ctx.expectError                                 (GL_NO_ERROR);
1195
1196         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1197         ctx.glGetFramebufferAttachmentParameteriv(-1, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &params[0]);                                  // TYPE is GL_RENDERBUFFER
1198         ctx.expectError(GL_INVALID_ENUM);
1199         ctx.endSection();
1200
1201         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not valid for the value of GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE.");
1202         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &params[0]);    // TYPE is GL_RENDERBUFFER
1203         ctx.expectError(GL_INVALID_ENUM);
1204         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1205         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_BACK, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);                                  // TYPE is GL_FRAMEBUFFER_DEFAULT
1206         ctx.expectError(GL_INVALID_ENUM);
1207         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1208         ctx.endSection();
1209
1210         ctx.beginSection("GL_INVALID_OPERATION is generated if attachment is GL_DEPTH_STENCIL_ATTACHMENT and different objects are bound to the depth and stencil attachment points of target.");
1211         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);
1212         ctx.expectError(GL_INVALID_OPERATION);
1213         ctx.endSection();
1214
1215         ctx.beginSection("GL_INVALID_OPERATION is generated if the value of GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is GL_NONE and pname is not GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME.");
1216         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);             // TYPE is GL_NONE
1217         ctx.expectError(GL_NO_ERROR);
1218         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, &params[0]);  // TYPE is GL_NONE
1219         ctx.expectError(GL_INVALID_OPERATION);
1220         ctx.endSection();
1221
1222         ctx.beginSection("GL_INVALID_OPERATION or GL_INVALID_ENUM is generated if attachment is not one of the accepted values for the current binding of target.");
1223         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_BACK, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);                                  // A FBO is bound so GL_BACK is invalid
1224         ctx.expectError(GL_INVALID_OPERATION, GL_INVALID_ENUM);
1225         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1226         ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);             // Default framebuffer is bound so GL_COLOR_ATTACHMENT0 is invalid
1227         ctx.expectError(GL_INVALID_OPERATION, GL_INVALID_ENUM);
1228         ctx.endSection();
1229
1230         ctx.glDeleteFramebuffers(1, &fbo);
1231 }
1232
1233 void get_renderbuffer_parameteriv (NegativeTestContext& ctx)
1234 {
1235         GLint   params[1] = { -1 };
1236         GLuint  rbo;
1237         ctx.glGenRenderbuffers(1, &rbo);
1238         ctx.glBindRenderbuffer(GL_RENDERBUFFER, rbo);
1239
1240         ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1241         ctx.glGetRenderbufferParameteriv(-1, GL_RENDERBUFFER_WIDTH, &params[0]);
1242         ctx.expectError(GL_INVALID_ENUM);
1243         ctx.endSection();
1244
1245         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the accepted tokens.");
1246         ctx.glGetRenderbufferParameteriv(GL_RENDERBUFFER, -1, &params[0]);
1247         ctx.expectError(GL_INVALID_ENUM);
1248         ctx.endSection();
1249
1250         ctx.beginSection("GL_INVALID_OPERATION  is generated if the renderbuffer currently bound to target is zero.");
1251         ctx.glBindRenderbuffer(GL_RENDERBUFFER, 0);
1252         ctx.expectError(GL_NO_ERROR);
1253         ctx.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &params[0]);
1254         ctx.expectError(GL_INVALID_OPERATION);
1255         ctx.endSection();
1256
1257         ctx.glDeleteRenderbuffers(1, &rbo);
1258         ctx.glBindRenderbuffer(GL_RENDERBUFFER, 0);
1259 }
1260
1261 void get_internalformativ (NegativeTestContext& ctx)
1262 {
1263         GLint params[16];
1264
1265         deMemset(&params[0], 0xcd, sizeof(params));
1266
1267         ctx.beginSection("GL_INVALID_VALUE is generated if bufSize is negative.");
1268         ctx.glGetInternalformativ       (GL_RENDERBUFFER, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, -1, &params[0]);
1269         ctx.expectError                         (GL_INVALID_VALUE);
1270         ctx.endSection();
1271
1272         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not GL_SAMPLES or GL_NUM_SAMPLE_COUNTS.");
1273         ctx.glGetInternalformativ       (GL_RENDERBUFFER, GL_RGBA8, -1, 16, &params[0]);
1274         ctx.expectError                         (GL_INVALID_ENUM);
1275         ctx.endSection();
1276
1277         ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not color-, depth-, or stencil-renderable.");
1278
1279         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_render_snorm"))
1280         {
1281                 ctx.glGetInternalformativ       (GL_RENDERBUFFER, GL_RG8_SNORM, GL_NUM_SAMPLE_COUNTS, 16, &params[0]);
1282                 ctx.expectError                         (GL_INVALID_ENUM);
1283         }
1284
1285         ctx.glGetInternalformativ       (GL_RENDERBUFFER, GL_COMPRESSED_RGB8_ETC2, GL_NUM_SAMPLE_COUNTS, 16, &params[0]);
1286         ctx.expectError                         (GL_INVALID_ENUM);
1287         ctx.endSection();
1288
1289         ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1290         ctx.glGetInternalformativ       (-1, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 16, &params[0]);
1291         ctx.expectError                         (GL_INVALID_ENUM);
1292         ctx.glGetInternalformativ       (GL_FRAMEBUFFER, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 16, &params[0]);
1293         ctx.expectError                         (GL_INVALID_ENUM);
1294
1295         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_sparse_texture"))
1296         {
1297                 ctx.glGetInternalformativ       (GL_TEXTURE_2D, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 16, &params[0]);
1298                 ctx.expectError                         (GL_INVALID_ENUM);
1299         }
1300
1301         ctx.endSection();
1302 }
1303
1304 // Query object queries
1305
1306 void get_queryiv (NegativeTestContext& ctx)
1307 {
1308         GLint params = -1;
1309
1310         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
1311         ctx.glGetQueryiv        (GL_ANY_SAMPLES_PASSED, -1, &params);
1312         ctx.expectError         (GL_INVALID_ENUM);
1313         ctx.glGetQueryiv        (-1, GL_CURRENT_QUERY, &params);
1314         ctx.expectError         (GL_INVALID_ENUM);
1315         ctx.glGetQueryiv        (-1, -1, &params);
1316         ctx.expectError         (GL_INVALID_ENUM);
1317         ctx.endSection();
1318 }
1319
1320 void get_query_objectuiv (NegativeTestContext& ctx)
1321 {
1322         GLuint params   = -1;
1323         GLuint id;
1324         ctx.glGenQueries                (1, &id);
1325
1326         ctx.beginSection("GL_INVALID_OPERATION is generated if id is not the name of a query object.");
1327         ctx.glGetQueryObjectuiv (-1, GL_QUERY_RESULT_AVAILABLE, &params);
1328         ctx.expectError                 (GL_INVALID_OPERATION);
1329         ctx.getLog() << TestLog::Message << "// Note: " << id << " is not a query object yet, since it hasn't been used by glBeginQuery" << TestLog::EndMessage;
1330         ctx.glGetQueryObjectuiv (id, GL_QUERY_RESULT_AVAILABLE, &params);
1331         ctx.expectError                 (GL_INVALID_OPERATION);
1332         ctx.endSection();
1333
1334         ctx.glBeginQuery                (GL_ANY_SAMPLES_PASSED, id);
1335         ctx.glEndQuery                  (GL_ANY_SAMPLES_PASSED);
1336
1337         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1338         ctx.glGetQueryObjectuiv (id, -1, &params);
1339         ctx.expectError                 (GL_INVALID_ENUM);
1340         ctx.endSection();
1341
1342         ctx.beginSection("GL_INVALID_OPERATION is generated if id is the name of a currently active query object.");
1343         ctx.glBeginQuery                (GL_ANY_SAMPLES_PASSED, id);
1344         ctx.expectError                 (GL_NO_ERROR);
1345         ctx.glGetQueryObjectuiv (id, GL_QUERY_RESULT_AVAILABLE, &params);
1346         ctx.expectError                 (GL_INVALID_OPERATION);
1347         ctx.glEndQuery                  (GL_ANY_SAMPLES_PASSED);
1348         ctx.expectError                 (GL_NO_ERROR);
1349         ctx.endSection();
1350
1351         ctx.glDeleteQueries             (1, &id);
1352 }
1353
1354 // Sync object queries
1355
1356 void get_synciv (NegativeTestContext& ctx)
1357 {
1358         GLsizei length          = -1;
1359         GLint   values[32];
1360         GLsync  sync;
1361
1362         deMemset(&values[0], 0xcd, sizeof(values));
1363
1364         ctx.beginSection("GL_INVALID_VALUE is generated if sync is not the name of a sync object.");
1365         ctx.glGetSynciv(0, GL_OBJECT_TYPE, 32, &length, &values[0]);
1366         ctx.expectError(GL_INVALID_VALUE);
1367         ctx.endSection();
1368
1369         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not one of the accepted tokens.");
1370         sync = ctx.glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
1371         ctx.expectError(GL_NO_ERROR);
1372         ctx.glGetSynciv(sync, -1, 32, &length, &values[0]);
1373         ctx.expectError(GL_INVALID_ENUM);
1374         ctx.endSection();
1375
1376         ctx.glDeleteSync(sync);
1377
1378         ctx.beginSection("GL_INVALID_VALUE is generated if bufSize is negative.");
1379         sync = ctx.glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
1380         ctx.expectError(GL_NO_ERROR);
1381         ctx.glGetSynciv(sync, GL_OBJECT_TYPE, -1, &length, &values[0]);
1382         ctx.expectError(GL_INVALID_VALUE);
1383         ctx.endSection();
1384
1385         ctx.glDeleteSync(sync);
1386 }
1387
1388 // Enumerated boolean state queries
1389
1390 void is_enabled (NegativeTestContext& ctx)
1391 {
1392         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not an accepted value.");
1393         ctx.glIsEnabled(-1);
1394         ctx.expectError(GL_INVALID_ENUM);
1395         ctx.glIsEnabled(GL_TRIANGLES);
1396         ctx.expectError(GL_INVALID_ENUM);
1397         ctx.endSection();
1398 }
1399
1400 void is_enabledi (NegativeTestContext& ctx)
1401 {
1402         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a higher context version.");
1403
1404         ctx.beginSection("GL_INVALID_ENUM is generated if cap is not an accepted value.");
1405         ctx.glIsEnabledi(-1, 1);
1406         ctx.expectError(GL_INVALID_ENUM);
1407         ctx.glIsEnabledi(GL_TRIANGLES, 1);
1408         ctx.expectError(GL_INVALID_ENUM);
1409         ctx.endSection();
1410
1411         ctx.beginSection("GL_INVALID_VALUE is generated if index is outside the valid range for the indexed state cap.");
1412         ctx.glIsEnabledi(GL_BLEND, -1);
1413         ctx.expectError(GL_INVALID_VALUE);
1414         ctx.endSection();
1415 }
1416
1417 // Hints
1418
1419 void hint (NegativeTestContext& ctx)
1420 {
1421         ctx.beginSection("GL_INVALID_ENUM is generated if either target or mode is not an accepted value.");
1422         ctx.glHint(GL_GENERATE_MIPMAP_HINT, -1);
1423         ctx.expectError(GL_INVALID_ENUM);
1424         ctx.glHint(-1, GL_FASTEST);
1425         ctx.expectError(GL_INVALID_ENUM);
1426         ctx.glHint(-1, -1);
1427         ctx.expectError(GL_INVALID_ENUM);
1428         ctx.endSection();
1429 }
1430
1431 std::vector<FunctionContainer> getNegativeStateApiTestFunctions ()
1432 {
1433         const FunctionContainer funcs[] =
1434         {
1435                 {enable,                                                                        "enable",                                                                       "Invalid glEnable() usage"                                                              },
1436                 {disable,                                                                       "disable",                                                                      "Invalid glDisable() usage"                                                             },
1437                 {get_booleanv,                                                          "get_booleanv",                                                         "Invalid glGetBooleanv() usage"                                                 },
1438                 {get_floatv,                                                            "get_floatv",                                                           "Invalid glGetFloatv() usage"                                                   },
1439                 {get_integerv,                                                          "get_integerv",                                                         "Invalid glGetIntegerv() usage"                                                 },
1440                 {get_integer64v,                                                        "get_integer64v",                                                       "Invalid glGetInteger64v() usage"                                               },
1441                 {get_integeri_v,                                                        "get_integeri_v",                                                       "Invalid glGetIntegeri_v() usage"                                               },
1442                 {get_booleani_v,                                                        "get_booleani_v",                                                       "Invalid glGetBooleani_v() usage"                                               },
1443                 {get_integer64i_v,                                                      "get_integer64i_v",                                                     "Invalid glGetInteger64i_v() usage"                                             },
1444                 {get_string,                                                            "get_string",                                                           "Invalid glGetString() usage"                                                   },
1445                 {get_stringi,                                                           "get_stringi",                                                          "Invalid glGetStringi() usage"                                                  },
1446                 {get_attached_shaders,                                          "get_attached_shaders",                                         "Invalid glGetAttachedShaders() usage"                                  },
1447                 {get_shaderiv,                                                          "get_shaderiv",                                                         "Invalid glGetShaderiv() usage"                                                 },
1448                 {get_shader_info_log,                                           "get_shader_info_log",                                          "Invalid glGetShaderInfoLog() usage"                                    },
1449                 {get_shader_precision_format,                           "get_shader_precision_format",                          "Invalid glGetShaderPrecisionFormat() usage"                    },
1450                 {get_shader_source,                                                     "get_shader_source",                                            "Invalid glGetShaderSource() usage"                                             },
1451                 {get_programiv,                                                         "get_programiv",                                                        "Invalid glGetProgramiv() usage"                                                },
1452                 {get_program_info_log,                                          "get_program_info_log",                                         "Invalid glGetProgramInfoLog() usage"                                   },
1453                 {get_tex_parameterfv,                                           "get_tex_parameterfv",                                          "Invalid glGetTexParameterfv() usage"                                   },
1454                 {get_tex_parameteriv,                                           "get_tex_parameteriv",                                          "Invalid glGetTexParameteriv() usage"                                   },
1455                 {get_uniformfv,                                                         "get_uniformfv",                                                        "Invalid glGetUniformfv() usage"                                                },
1456                 {get_uniformiv,                                                         "get_uniformiv",                                                        "Invalid glGetUniformiv() usage"                                                },
1457                 {get_uniformuiv,                                                        "get_uniformuiv",                                                       "Invalid glGetUniformuiv() usage"                                               },
1458                 {get_active_uniform,                                            "get_active_uniform",                                           "Invalid glGetActiveUniform() usage"                                    },
1459                 {get_active_uniformsiv,                                         "get_active_uniformsiv",                                        "Invalid glGetActiveUniformsiv() usage"                                 },
1460                 {get_active_uniform_blockiv,                            "get_active_uniform_blockiv",                           "Invalid glGetActiveUniformBlockiv() usage"                             },
1461                 {get_active_uniform_block_name,                         "get_active_uniform_block_name",                        "Invalid glGetActiveUniformBlockName() usage"                   },
1462                 {get_active_attrib,                                                     "get_active_attrib",                                            "Invalid glGetActiveAttrib() usage"                                             },
1463                 {get_uniform_indices,                                           "get_uniform_indices",                                          "Invalid glGetUniformIndices() usage"                                   },
1464                 {get_vertex_attribfv,                                           "get_vertex_attribfv",                                          "Invalid glGetVertexAttribfv() usage"                                   },
1465                 {get_vertex_attribiv,                                           "get_vertex_attribiv",                                          "Invalid glGetVertexAttribiv() usage"                                   },
1466                 {get_vertex_attribi_iv,                                         "get_vertex_attribi_iv",                                        "Invalid glGetVertexAttribIiv() usage"                                  },
1467                 {get_vertex_attribi_uiv,                                        "get_vertex_attribi_uiv",                                       "Invalid glGetVertexAttribIuiv() usage"                                 },
1468                 {get_vertex_attrib_pointerv,                            "get_vertex_attrib_pointerv",                           "Invalid glGetVertexAttribPointerv() usage"                             },
1469                 {get_frag_data_location,                                        "get_frag_data_location",                                       "Invalid glGetFragDataLocation() usage"                                 },
1470                 {get_buffer_parameteriv,                                        "get_buffer_parameteriv",                                       "Invalid glGetBufferParameteriv() usage"                                },
1471                 {get_buffer_parameteri64v,                                      "get_buffer_parameteri64v",                                     "Invalid glGetBufferParameteri64v() usage"                              },
1472                 {get_buffer_pointerv,                                           "get_buffer_pointerv",                                          "Invalid glGetBufferPointerv() usage"                                   },
1473                 {get_framebuffer_attachment_parameteriv,        "get_framebuffer_attachment_parameteriv",       "Invalid glGetFramebufferAttachmentParameteriv() usage" },
1474                 {get_renderbuffer_parameteriv,                          "get_renderbuffer_parameteriv",                         "Invalid glGetRenderbufferParameteriv() usage"                  },
1475                 {get_internalformativ,                                          "get_internalformativ",                                         "Invalid glGetInternalformativ() usage"                                 },
1476                 {get_queryiv,                                                           "get_queryiv",                                                          "Invalid glGetQueryiv() usage"                                                  },
1477                 {get_query_objectuiv,                                           "get_query_objectuiv",                                          "Invalid glGetQueryObjectuiv() usage"                                   },
1478                 {get_synciv,                                                            "get_synciv",                                                           "Invalid glGetSynciv() usage"                                                   },
1479                 {is_enabled,                                                            "is_enabled",                                                           "Invalid glIsEnabled() usage"                                                   },
1480                 {hint,                                                                          "hint",                                                                         "Invalid glHint() usage"                                                                },
1481                 {enablei,                                                                       "enablei",                                                                      "Invalid glEnablei() usage"                                                             },
1482                 {disablei,                                                                      "disablei",                                                                     "Invalid glDisablei() usage"                                                    },
1483                 {get_tex_parameteriiv,                                          "get_tex_parameteriiv",                                         "Invalid glGetTexParameterIiv() usage"                                  },
1484                 {get_tex_parameteriuiv,                                         "get_tex_parameteriuiv",                                        "Invalid glGetTexParameterIuiv() usage"                                 },
1485                 {get_nuniformfv,                                                        "get_nuniformfv",                                                       "Invalid glGetnUniformfv() usage"                                               },
1486                 {get_nuniformiv,                                                        "get_nuniformiv",                                                       "Invalid glGetnUniformiv() usage"                                               },
1487                 {get_nuniformuiv,                                                       "get_nuniformuiv",                                                      "Invalid glGetnUniformuiv() usage"                                              },
1488                 {is_enabledi,                                                           "is_enabledi",                                                          "Invalid glIsEnabledi() usage"                                                  },
1489         };
1490
1491         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
1492 }
1493
1494 } // NegativeTestShared
1495 } // Functional
1496 } // gles3
1497 } // deqp