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 40namespace deqp 41{ 42namespace gles31 43{ 44namespace Functional 45{ 46namespace NegativeTestShared 47{ 48 49using tcu::TestLog; 50using glu::CallLogWrapper; 51using namespace glw; 52 53static 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 62static 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 71static 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 83void 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 92void 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 107void 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 115void 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 131void 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, ¶ms); 136 ctx.expectError(GL_INVALID_ENUM); 137 ctx.endSection(); 138} 139 140void 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 158void 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, ¶ms); 163 ctx.expectError(GL_INVALID_ENUM); 164 ctx.endSection(); 165} 166 167void 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, ¶ms); 172 ctx.expectError(GL_INVALID_ENUM); 173 ctx.endSection(); 174} 175 176void 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, ¶ms); 181 ctx.expectError(GL_INVALID_ENUM); 182 ctx.endSection(); 183} 184 185void 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 211void 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 239void 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 247void 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 265void 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 291void 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, ¶m[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, ¶m[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, ¶m[0]); 313 ctx.expectError(GL_INVALID_OPERATION); 314 ctx.endSection(); 315 316 ctx.glDeleteShader(shader); 317 ctx.glDeleteProgram(program); 318} 319 320void 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 346void 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 368void 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 396void 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, ¶ms[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, ¶ms[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, ¶ms[0]); 414 ctx.expectError(GL_INVALID_OPERATION); 415 ctx.endSection(); 416 417 ctx.glDeleteProgram(program); 418 ctx.glDeleteShader(shader); 419} 420 421void 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 449void 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, ¶ms[0]); 455 ctx.expectError(GL_INVALID_ENUM); 456 ctx.glGetTexParameterfv (GL_TEXTURE_2D, -1, ¶ms[0]); 457 ctx.expectError(GL_INVALID_ENUM); 458 ctx.glGetTexParameterfv (-1, -1, ¶ms[0]); 459 ctx.expectError(GL_INVALID_ENUM); 460 ctx.endSection(); 461} 462 463void 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, ¶ms[0]); 469 ctx.expectError(GL_INVALID_ENUM); 470 ctx.glGetTexParameteriv (GL_TEXTURE_2D, -1, ¶ms[0]); 471 ctx.expectError(GL_INVALID_ENUM); 472 ctx.glGetTexParameteriv (-1, -1, ¶ms[0]); 473 ctx.expectError(GL_INVALID_ENUM); 474 ctx.endSection(); 475} 476 477void 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, ¶ms[0]); 485 ctx.expectError(GL_INVALID_ENUM); 486 ctx.glGetTexParameterIiv(GL_TEXTURE_2D, -1, ¶ms[0]); 487 ctx.expectError(GL_INVALID_ENUM); 488 ctx.glGetTexParameterIiv(-1, -1, ¶ms[0]); 489 ctx.expectError(GL_INVALID_ENUM); 490 ctx.endSection(); 491} 492 493void 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, ¶ms[0]); 501 ctx.expectError(GL_INVALID_ENUM); 502 ctx.glGetTexParameterIuiv(GL_TEXTURE_2D, -1, ¶ms[0]); 503 ctx.expectError(GL_INVALID_ENUM); 504 ctx.glGetTexParameterIuiv(-1, -1, ¶ms[0]); 505 ctx.expectError(GL_INVALID_ENUM); 506 ctx.endSection(); 507} 508 509void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 543 ctx.expectError(GL_INVALID_OPERATION); 544 ctx.endSection(); 545 546 ctx.glDeleteShader(shader); 547 ctx.glDeleteProgram(programEmpty); 548} 549 550void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 593 ctx.expectError(GL_INVALID_OPERATION); 594 ctx.endSection(); 595 596 ctx.glDeleteShader(shader); 597 ctx.glDeleteProgram(programEmpty); 598} 599 600void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 633 ctx.expectError(GL_INVALID_OPERATION); 634 ctx.endSection(); 635 636 ctx.glDeleteShader(shader); 637 ctx.glDeleteProgram(programEmpty); 638} 639 640void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 683 ctx.expectError(GL_INVALID_OPERATION); 684 ctx.endSection(); 685 686 ctx.glDeleteShader(shader); 687 ctx.glDeleteProgram(programEmpty); 688} 689 690void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 723 ctx.expectError(GL_INVALID_OPERATION); 724 ctx.endSection(); 725 726 ctx.glDeleteShader(shader); 727 ctx.glDeleteProgram(programEmpty); 728} 729 730void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 773 ctx.expectError(GL_INVALID_OPERATION); 774 ctx.endSection(); 775 776 ctx.glDeleteShader(shader); 777 ctx.glDeleteProgram(programEmpty); 778} 779 780void 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 814void 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 860void 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, ¶ms); 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, ¶ms); 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, ¶ms); 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, ¶ms); 890 ctx.expectError(GL_INVALID_ENUM); 891 ctx.endSection(); 892 893 ctx.glUseProgram(0); 894} 895 896void 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 930void 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 971void 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 998void 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, ¶ms); 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, ¶ms); 1011 ctx.expectError(GL_INVALID_VALUE); 1012 ctx.endSection(); 1013} 1014 1015void 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, ¶ms); 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, ¶ms); 1028 ctx.expectError(GL_INVALID_VALUE); 1029 ctx.endSection(); 1030} 1031 1032void 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, ¶ms); 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, ¶ms); 1045 ctx.expectError(GL_INVALID_VALUE); 1046 ctx.endSection(); 1047} 1048 1049void 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, ¶ms); 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, ¶ms); 1062 ctx.expectError(GL_INVALID_VALUE); 1063 ctx.endSection(); 1064} 1065 1066void 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 1083void 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 1104void 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, ¶ms); 1113 ctx.expectError(GL_INVALID_ENUM); 1114 ctx.glGetBufferParameteriv(GL_ARRAY_BUFFER, -1, ¶ms); 1115 ctx.expectError(GL_INVALID_ENUM); 1116 ctx.glGetBufferParameteriv(-1, -1, ¶ms); 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, ¶ms); 1123 ctx.expectError(GL_INVALID_OPERATION); 1124 ctx.endSection(); 1125 1126 ctx.glDeleteBuffers(1, &buf); 1127} 1128 1129void 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, ¶ms); 1138 ctx.expectError(GL_INVALID_ENUM); 1139 ctx.glGetBufferParameteri64v(GL_ARRAY_BUFFER , -1, ¶ms); 1140 ctx.expectError(GL_INVALID_ENUM); 1141 ctx.glGetBufferParameteri64v(-1, -1, ¶ms); 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, ¶ms); 1148 ctx.expectError(GL_INVALID_OPERATION); 1149 ctx.endSection(); 1150 1151 ctx.glDeleteBuffers(1, &buf); 1152} 1153 1154void 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, ¶ms); 1163 ctx.expectError(GL_INVALID_ENUM); 1164 ctx.glGetBufferPointerv(-1, GL_BUFFER_MAP_POINTER, ¶ms); 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, ¶ms); 1171 ctx.expectError(GL_INVALID_OPERATION); 1172 ctx.endSection(); 1173 1174 ctx.glDeleteBuffers(1, &buf); 1175} 1176 1177void 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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); // TYPE is GL_NONE 1217 ctx.expectError(GL_NO_ERROR); 1218 ctx.glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, ¶ms[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, ¶ms[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, ¶ms[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 1233void 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, ¶ms[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, ¶ms[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, ¶ms[0]); 1254 ctx.expectError(GL_INVALID_OPERATION); 1255 ctx.endSection(); 1256 1257 ctx.glDeleteRenderbuffers(1, &rbo); 1258 ctx.glBindRenderbuffer(GL_RENDERBUFFER, 0); 1259} 1260 1261void get_internalformativ (NegativeTestContext& ctx) 1262{ 1263 GLint params[16]; 1264 1265 deMemset(¶ms[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, ¶ms[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, ¶ms[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, ¶ms[0]); 1282 ctx.expectError (GL_INVALID_ENUM); 1283 } 1284 1285 ctx.glGetInternalformativ (GL_RENDERBUFFER, GL_COMPRESSED_RGB8_ETC2, GL_NUM_SAMPLE_COUNTS, 16, ¶ms[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, ¶ms[0]); 1291 ctx.expectError (GL_INVALID_ENUM); 1292 ctx.glGetInternalformativ (GL_FRAMEBUFFER, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 16, ¶ms[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, ¶ms[0]); 1298 ctx.expectError (GL_INVALID_ENUM); 1299 } 1300 1301 ctx.endSection(); 1302} 1303 1304// Query object queries 1305 1306void 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, ¶ms); 1312 ctx.expectError (GL_INVALID_ENUM); 1313 ctx.glGetQueryiv (-1, GL_CURRENT_QUERY, ¶ms); 1314 ctx.expectError (GL_INVALID_ENUM); 1315 ctx.glGetQueryiv (-1, -1, ¶ms); 1316 ctx.expectError (GL_INVALID_ENUM); 1317 ctx.endSection(); 1318} 1319 1320void 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, ¶ms); 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, ¶ms); 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, ¶ms); 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, ¶ms); 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 1356void 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 1390void 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 1400void 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 1419void 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 1431std::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 1498