1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Negative Shader API tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fNegativeShaderApiTests.hpp" 25 26 #include "deUniquePtr.hpp" 27 28 #include "glwDefs.hpp" 29 #include "glwEnums.hpp" 30 31 #include "gluShaderProgram.hpp" 32 #include "gluCallLogWrapper.hpp" 33 34 #include "gluContextInfo.hpp" 35 #include "gluRenderContext.hpp" 36 37 38 namespace deqp 39 { 40 namespace gles31 41 { 42 namespace Functional 43 { 44 namespace NegativeTestShared 45 { 46 using tcu::TestLog; 47 using glu::CallLogWrapper; 48 using namespace glw; 49 50 static const char* vertexShaderSource = "#version 300 es\n" 51 "void main (void)\n" 52 "{\n" 53 " gl_Position = vec4(0.0);\n" 54 "}\n\0"; 55 56 static const char* fragmentShaderSource = "#version 300 es\n" 57 "layout(location = 0) out mediump vec4 fragColor;" 58 "void main (void)\n" 59 "{\n" 60 " fragColor = vec4(0.0);\n" 61 "}\n\0"; 62 63 static const char* uniformTestVertSource = "#version 300 es\n" 64 "uniform mediump vec4 vec4_v;\n" 65 "uniform mediump mat4 mat4_v;\n" 66 "void main (void)\n" 67 "{\n" 68 " gl_Position = mat4_v * vec4_v;\n" 69 "}\n\0"; 70 71 static const char* uniformTestFragSource = "#version 300 es\n" 72 "uniform mediump ivec4 ivec4_f;\n" 73 "uniform mediump uvec4 uvec4_f;\n" 74 "uniform sampler2D sampler_f;\n" 75 "layout(location = 0) out mediump vec4 fragColor;" 76 "void main (void)\n" 77 "{\n" 78 " fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n" 79 " fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n" 80 "}\n\0"; 81 82 static const char* uniformBlockVertSource = "#version 300 es\n" 83 "layout(shared) uniform Block { lowp float var; };\n" 84 "void main (void)\n" 85 "{\n" 86 " gl_Position = vec4(var);\n" 87 "}\n\0"; 88 89 90 // Shader control commands 91 void create_shader (NegativeTestContext& ctx) 92 { 93 ctx.beginSection("GL_INVALID_ENUM is generated if shaderType is not an accepted value."); 94 ctx.glCreateShader(-1); 95 ctx.expectError(GL_INVALID_ENUM); 96 ctx.endSection(); 97 } 98 99 void shader_source (NegativeTestContext& ctx) 100 { 101 // make notAShader not a shader id 102 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER); 103 ctx.glDeleteShader(notAShader); 104 105 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL."); 106 ctx.glShaderSource(notAShader, 0, 0, 0); 107 ctx.expectError(GL_INVALID_VALUE); 108 ctx.endSection(); 109 110 ctx.beginSection("GL_INVALID_VALUE is generated if count is less than 0."); 111 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 112 ctx.glShaderSource(shader, -1, 0, 0); 113 ctx.expectError(GL_INVALID_VALUE); 114 ctx.endSection(); 115 116 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object."); 117 GLuint program = ctx.glCreateProgram(); 118 ctx.glShaderSource(program, 0, 0, 0); 119 ctx.expectError(GL_INVALID_OPERATION); 120 ctx.endSection(); 121 122 ctx.glDeleteProgram(program); 123 ctx.glDeleteShader(shader); 124 } 125 126 void compile_shader (NegativeTestContext& ctx) 127 { 128 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER); 129 ctx.glDeleteShader(notAShader); 130 131 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL."); 132 ctx.glCompileShader(notAShader); 133 ctx.expectError(GL_INVALID_VALUE); 134 ctx.endSection(); 135 136 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object."); 137 GLuint program = ctx.glCreateProgram(); 138 ctx.glCompileShader(program); 139 ctx.expectError(GL_INVALID_OPERATION); 140 ctx.endSection(); 141 142 ctx.glDeleteProgram(program); 143 } 144 145 void delete_shader (NegativeTestContext& ctx) 146 { 147 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER); 148 ctx.glDeleteShader(notAShader); 149 150 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL."); 151 ctx.glDeleteShader(notAShader); 152 ctx.expectError(GL_INVALID_VALUE); 153 ctx.endSection(); 154 } 155 156 void shader_binary (NegativeTestContext& ctx) 157 { 158 std::vector<deInt32> binaryFormats; 159 deBool shaderBinarySupported = !binaryFormats.empty(); 160 GLuint shaders[2]; 161 GLuint shaderPair[2]; 162 GLuint nonProgram[2]; 163 GLuint shaderProgram[2]; 164 165 { 166 deInt32 numFormats = 0x1234; 167 ctx.glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &numFormats); 168 169 if (numFormats == 0) 170 ctx.getLog() << TestLog::Message << "// No supported extensions available." << TestLog::EndMessage; 171 else 172 { 173 binaryFormats.resize(numFormats); 174 ctx.glGetIntegerv(GL_SHADER_BINARY_FORMATS, &binaryFormats[0]); 175 } 176 } 177 178 if (!shaderBinarySupported) 179 ctx.getLog() << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage; 180 else 181 ctx.getLog() << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage; 182 183 shaders[0] = ctx.glCreateShader(GL_VERTEX_SHADER); 184 shaders[1] = ctx.glCreateShader(GL_VERTEX_SHADER); 185 shaderPair[0] = ctx.glCreateShader(GL_VERTEX_SHADER); 186 shaderPair[1] = ctx.glCreateShader(GL_FRAGMENT_SHADER); 187 nonProgram[0] = -1; 188 nonProgram[1] = -1; 189 shaderProgram[0] = ctx.glCreateShader(GL_VERTEX_SHADER); 190 shaderProgram[1] = ctx.glCreateProgram(); 191 192 ctx.beginSection("GL_INVALID_ENUM is generated if binaryFormat is not an accepted value."); 193 ctx.glShaderBinary(1, &shaders[0], -1, 0, 0); 194 ctx.expectError(GL_INVALID_ENUM); 195 ctx.endSection(); 196 197 if (shaderBinarySupported) 198 { 199 ctx.beginSection("GL_INVALID_VALUE is generated if the data pointed to by binary does not match the format specified by binaryFormat."); 200 const GLbyte data = 0x005F; 201 ctx.glShaderBinary(1, &shaders[0], binaryFormats[0], &data, 1); 202 ctx.expectError(GL_INVALID_VALUE); 203 ctx.endSection(); 204 205 ctx.beginSection("GL_INVALID_OPERATION is generated if more than one of the handles in shaders refers to the same type of shader, or GL_INVALID_VALUE due to invalid data pointer."); 206 ctx.glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0); 207 ctx.expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE); 208 ctx.endSection(); 209 210 ctx.beginSection("GL_INVALID_VALUE is generated if count or length is negative."); 211 ctx.glShaderBinary(2, &shaderPair[0], binaryFormats[0], 0, -1); 212 ctx.expectError(GL_INVALID_VALUE); 213 ctx.glShaderBinary(-1, &shaderPair[0], binaryFormats[0], 0, 0); 214 ctx.expectError(GL_INVALID_VALUE); 215 ctx.endSection(); 216 217 ctx.beginSection("GL_INVALID_VALUE is generated if shaders contains anything other than shader or program objects."); 218 ctx.glShaderBinary(2, &nonProgram[0], binaryFormats[0], 0, 0); 219 ctx.expectError(GL_INVALID_VALUE); 220 ctx.endSection(); 221 222 ctx.beginSection("GL_INVALID_OPERATION is generated if shaders refers to a program object."); 223 ctx.glShaderBinary(2, &shaderProgram[0], binaryFormats[0], 0, 0); 224 ctx.expectError(GL_INVALID_OPERATION); 225 ctx.endSection(); 226 } 227 228 ctx.glDeleteShader(shaders[0]); 229 ctx.glDeleteShader(shaders[1]); 230 } 231 232 void attach_shader (NegativeTestContext& ctx) 233 { 234 GLuint shader1 = ctx.glCreateShader(GL_VERTEX_SHADER); 235 GLuint shader2 = ctx.glCreateShader(GL_VERTEX_SHADER); 236 GLuint program = ctx.glCreateProgram(); 237 238 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER); 239 const GLuint notAProgram = ctx.glCreateProgram(); 240 241 ctx.glDeleteShader(notAShader); 242 ctx.glDeleteProgram(notAProgram); 243 244 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 245 ctx.glAttachShader(shader1, shader1); 246 ctx.expectError(GL_INVALID_OPERATION); 247 ctx.endSection(); 248 249 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object."); 250 ctx.glAttachShader(program, program); 251 ctx.expectError(GL_INVALID_OPERATION); 252 ctx.glAttachShader(shader1, program); 253 ctx.expectError(GL_INVALID_OPERATION); 254 ctx.endSection(); 255 256 ctx.beginSection("GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL."); 257 ctx.glAttachShader(program, notAShader); 258 ctx.expectError(GL_INVALID_VALUE); 259 ctx.glAttachShader(notAProgram, shader1); 260 ctx.expectError(GL_INVALID_VALUE); 261 ctx.glAttachShader(notAProgram, notAShader); 262 ctx.expectError(GL_INVALID_VALUE); 263 ctx.endSection(); 264 265 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is already attached to program."); 266 ctx.glAttachShader(program, shader1); 267 ctx.expectError(GL_NO_ERROR); 268 ctx.glAttachShader(program, shader1); 269 ctx.expectError(GL_INVALID_OPERATION); 270 ctx.endSection(); 271 272 ctx.beginSection("GL_INVALID_OPERATION is generated if a shader of the same type as shader is already attached to program."); 273 ctx.glAttachShader(program, shader2); 274 ctx.expectError(GL_INVALID_OPERATION); 275 ctx.endSection(); 276 277 ctx.glDeleteProgram(program); 278 ctx.glDeleteShader(shader1); 279 ctx.glDeleteShader(shader2); 280 } 281 282 void detach_shader (NegativeTestContext& ctx) 283 { 284 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 285 GLuint program = ctx.glCreateProgram(); 286 287 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER); 288 const GLuint notAProgram = ctx.glCreateProgram(); 289 290 ctx.glDeleteShader(notAShader); 291 ctx.glDeleteProgram(notAProgram); 292 293 ctx.beginSection("GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL."); 294 ctx.glDetachShader(notAProgram, shader); 295 ctx.expectError(GL_INVALID_VALUE); 296 ctx.glDetachShader(program, notAShader); 297 ctx.expectError(GL_INVALID_VALUE); 298 ctx.glDetachShader(notAProgram, notAShader); 299 ctx.expectError(GL_INVALID_VALUE); 300 ctx.endSection(); 301 302 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 303 ctx.glDetachShader(shader, shader); 304 ctx.expectError(GL_INVALID_OPERATION); 305 ctx.endSection(); 306 307 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object."); 308 ctx.glDetachShader(program, program); 309 ctx.expectError(GL_INVALID_OPERATION); 310 ctx.glDetachShader(shader, program); 311 ctx.expectError(GL_INVALID_OPERATION); 312 ctx.endSection(); 313 314 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not attached to program."); 315 ctx.glDetachShader(program, shader); 316 ctx.expectError(GL_INVALID_OPERATION); 317 ctx.endSection(); 318 319 ctx.glDeleteProgram(program); 320 ctx.glDeleteShader(shader); 321 } 322 323 void link_program (NegativeTestContext& ctx) 324 { 325 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 326 327 const GLuint notAProgram = ctx.glCreateProgram(); 328 ctx.glDeleteProgram(notAProgram); 329 330 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL."); 331 ctx.glLinkProgram(notAProgram); 332 ctx.expectError(GL_INVALID_VALUE); 333 ctx.endSection(); 334 335 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 336 ctx.glLinkProgram(shader); 337 ctx.expectError(GL_INVALID_OPERATION); 338 ctx.endSection(); 339 340 ctx.glDeleteShader(shader); 341 342 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the currently active program object and transform feedback mode is active."); 343 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 344 deUint32 buf = 0x1234; 345 deUint32 tfID = 0x1234; 346 const char* tfVarying = "gl_Position"; 347 348 ctx.glGenTransformFeedbacks (1, &tfID); 349 ctx.glGenBuffers (1, &buf); 350 351 ctx.glUseProgram (program.getProgram()); 352 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 353 ctx.glLinkProgram (program.getProgram()); 354 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID); 355 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 356 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 357 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 358 ctx.glBeginTransformFeedback (GL_TRIANGLES); 359 ctx.expectError (GL_NO_ERROR); 360 361 ctx.glLinkProgram (program.getProgram()); 362 ctx.expectError (GL_INVALID_OPERATION); 363 364 ctx.glEndTransformFeedback (); 365 ctx.glDeleteTransformFeedbacks (1, &tfID); 366 ctx.glDeleteBuffers (1, &buf); 367 ctx.expectError (GL_NO_ERROR); 368 ctx.endSection(); 369 } 370 371 void use_program (NegativeTestContext& ctx) 372 { 373 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 374 375 const GLuint notAProgram = ctx.glCreateProgram(); 376 ctx.glDeleteProgram(notAProgram); 377 378 ctx.beginSection("GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL."); 379 ctx.glUseProgram(notAProgram); 380 ctx.expectError(GL_INVALID_VALUE); 381 ctx.endSection(); 382 383 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 384 ctx.glUseProgram(shader); 385 ctx.expectError(GL_INVALID_OPERATION); 386 ctx.endSection(); 387 388 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback mode is active and not paused."); 389 glu::ShaderProgram program1(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 390 glu::ShaderProgram program2(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 391 deUint32 buf = 0x1234; 392 deUint32 tfID = 0x1234; 393 const char* tfVarying = "gl_Position"; 394 395 ctx.glGenTransformFeedbacks (1, &tfID); 396 ctx.glGenBuffers (1, &buf); 397 398 ctx.glUseProgram (program1.getProgram()); 399 ctx.glTransformFeedbackVaryings (program1.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 400 ctx.glLinkProgram (program1.getProgram()); 401 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID); 402 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 403 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 404 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 405 ctx.glBeginTransformFeedback (GL_TRIANGLES); 406 ctx.expectError (GL_NO_ERROR); 407 408 ctx.glUseProgram (program2.getProgram()); 409 ctx.expectError (GL_INVALID_OPERATION); 410 411 ctx.glPauseTransformFeedback (); 412 ctx.glUseProgram (program2.getProgram()); 413 ctx.expectError (GL_NO_ERROR); 414 415 ctx.glEndTransformFeedback (); 416 ctx.glDeleteTransformFeedbacks (1, &tfID); 417 ctx.glDeleteBuffers (1, &buf); 418 ctx.expectError (GL_NO_ERROR); 419 ctx.endSection(); 420 421 ctx.glUseProgram(0); 422 ctx.glDeleteShader(shader); 423 } 424 425 void delete_program (NegativeTestContext& ctx) 426 { 427 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 428 429 const GLuint notAProgram = ctx.glCreateProgram(); 430 ctx.glDeleteProgram(notAProgram); 431 432 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL."); 433 ctx.glDeleteProgram(notAProgram); 434 ctx.expectError(GL_INVALID_VALUE); 435 ctx.endSection(); 436 437 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not zero and is the name of a shader object."); 438 ctx.glDeleteProgram(shader); 439 ctx.expectError(GL_INVALID_OPERATION); 440 ctx.endSection(); 441 442 ctx.glDeleteShader(shader); 443 } 444 445 void validate_program (NegativeTestContext& ctx) 446 { 447 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 448 449 const GLuint notAProgram = ctx.glCreateProgram(); 450 ctx.glDeleteProgram(notAProgram); 451 452 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL."); 453 ctx.glValidateProgram(notAProgram); 454 ctx.expectError(GL_INVALID_VALUE); 455 ctx.endSection(); 456 457 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 458 ctx.glValidateProgram(shader); 459 ctx.expectError(GL_INVALID_OPERATION); 460 ctx.endSection(); 461 462 ctx.glDeleteShader(shader); 463 } 464 465 void get_program_binary (NegativeTestContext& ctx) 466 { 467 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 468 glu::ShaderProgram programInvalid (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, "")); 469 GLenum binaryFormat = -1; 470 GLsizei binaryLength = -1; 471 GLint binaryPtr = -1; 472 GLint bufSize = -1; 473 GLint linkStatus = -1; 474 475 ctx.beginSection("GL_INVALID_OPERATION is generated if bufSize is less than the size of GL_PROGRAM_BINARY_LENGTH for program."); 476 ctx.glGetProgramiv (program.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize); 477 ctx.expectError (GL_NO_ERROR); 478 ctx.glGetProgramiv (program.getProgram(), GL_LINK_STATUS, &linkStatus); 479 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage; 480 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage; 481 ctx.expectError (GL_NO_ERROR); 482 483 ctx.glGetProgramBinary (program.getProgram(), 0, &binaryLength, &binaryFormat, &binaryPtr); 484 ctx.expectError (GL_INVALID_OPERATION); 485 if (bufSize > 0) 486 { 487 ctx.glGetProgramBinary (program.getProgram(), bufSize-1, &binaryLength, &binaryFormat, &binaryPtr); 488 ctx.expectError (GL_INVALID_OPERATION); 489 } 490 ctx.endSection(); 491 492 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_LINK_STATUS for the program object is false."); 493 ctx.glGetProgramiv (programInvalid.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize); 494 ctx.expectError (GL_NO_ERROR); 495 ctx.glGetProgramiv (programInvalid.getProgram(), GL_LINK_STATUS, &linkStatus); 496 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage; 497 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage; 498 ctx.expectError (GL_NO_ERROR); 499 500 ctx.glGetProgramBinary (programInvalid.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryPtr); 501 ctx.expectError (GL_INVALID_OPERATION); 502 ctx.endSection(); 503 } 504 505 void program_binary (NegativeTestContext& ctx) 506 { 507 glu::ShaderProgram srcProgram (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 508 GLuint dstProgram = ctx.glCreateProgram(); 509 GLuint dummyShader = ctx.glCreateShader(GL_VERTEX_SHADER); 510 GLenum binaryFormat = -1; 511 GLsizei binaryLength = -1; 512 std::vector<deUint8> binaryBuf; 513 GLint bufSize = -1; 514 GLint linkStatus = -1; 515 516 ctx.glGetProgramiv (srcProgram.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize); 517 ctx.glGetProgramiv (srcProgram.getProgram(), GL_LINK_STATUS, &linkStatus); 518 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage; 519 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage; 520 521 TCU_CHECK(bufSize >= 0); 522 if (bufSize > 0) 523 { 524 binaryBuf.resize(bufSize); 525 ctx.glGetProgramBinary (srcProgram.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryBuf[0]); 526 ctx.expectError (GL_NO_ERROR); 527 528 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not the name of an existing program object."); 529 ctx.glProgramBinary (dummyShader, binaryFormat, &binaryBuf[0], binaryLength); 530 ctx.expectError (GL_INVALID_OPERATION); 531 ctx.endSection(); 532 533 ctx.beginSection("GL_INVALID_ENUM is generated if binaryFormat is not a value recognized by the implementation."); 534 ctx.glProgramBinary (dstProgram, -1, &binaryBuf[0], binaryLength); 535 ctx.expectError (GL_INVALID_ENUM); 536 ctx.endSection(); 537 } 538 539 ctx.glDeleteShader(dummyShader); 540 ctx.glDeleteProgram(dstProgram); 541 } 542 543 void program_parameteri (NegativeTestContext& ctx) 544 { 545 GLuint program = ctx.glCreateProgram(); 546 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 547 548 const GLuint notAProgram = ctx.glCreateProgram(); 549 ctx.glDeleteProgram(notAProgram); 550 551 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of an existing program object."); 552 ctx.glProgramParameteri(notAProgram, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE); 553 ctx.expectError(GL_INVALID_VALUE); 554 ctx.endSection(); 555 556 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object."); 557 ctx.glProgramParameteri(shader, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE); 558 ctx.expectError(GL_INVALID_OPERATION); 559 ctx.endSection(); 560 561 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT or PROGRAM_SEPARABLE."); 562 ctx.glProgramParameteri(program, -1, GL_TRUE); 563 ctx.expectError(GL_INVALID_ENUM); 564 ctx.endSection(); 565 566 ctx.beginSection("GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE."); 567 ctx.glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2); 568 ctx.expectError(GL_INVALID_VALUE); 569 ctx.endSection(); 570 571 ctx.glDeleteProgram(program); 572 ctx.glDeleteShader(shader); 573 } 574 575 void gen_samplers (NegativeTestContext& ctx) 576 { 577 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 578 GLuint sampler = 0; 579 ctx.glGenSamplers (-1, &sampler); 580 ctx.expectError (GL_INVALID_VALUE); 581 ctx.endSection(); 582 } 583 584 void bind_sampler (NegativeTestContext& ctx) 585 { 586 int maxTexImageUnits = 0x1234; 587 GLuint sampler = 0; 588 ctx.glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits); 589 ctx.glGenSamplers (1, &sampler); 590 591 ctx.beginSection("GL_INVALID_VALUE is generated if unit is greater than or equal to the value of GL_MAX_COMBIED_TEXTURE_IMAGE_UNITS."); 592 ctx.glBindSampler (maxTexImageUnits, sampler); 593 ctx.expectError (GL_INVALID_VALUE); 594 ctx.endSection(); 595 596 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not zero or a name previously returned from a call to ctx.glGenSamplers."); 597 ctx.glBindSampler (1, -1); 598 ctx.expectError (GL_INVALID_OPERATION); 599 ctx.endSection(); 600 601 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler has been deleted by a call to ctx.glDeleteSamplers."); 602 ctx.glDeleteSamplers(1, &sampler); 603 ctx.glBindSampler (1, sampler); 604 ctx.expectError (GL_INVALID_OPERATION); 605 ctx.endSection(); 606 } 607 608 void delete_samplers (NegativeTestContext& ctx) 609 { 610 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 611 ctx.glDeleteSamplers(-1, 0); 612 ctx.expectError (GL_INVALID_VALUE); 613 ctx.endSection(); 614 } 615 616 void get_sampler_parameteriv (NegativeTestContext& ctx) 617 { 618 int params = 0x1234; 619 GLuint sampler = 0; 620 ctx.glGenSamplers (1, &sampler); 621 622 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers."); 623 ctx.glGetSamplerParameteriv (-1, GL_TEXTURE_MAG_FILTER, ¶ms); 624 ctx.expectError (GL_INVALID_OPERATION); 625 ctx.endSection(); 626 627 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value."); 628 ctx.glGetSamplerParameteriv (sampler, -1, ¶ms); 629 ctx.expectError (GL_INVALID_ENUM); 630 ctx.endSection(); 631 632 ctx.glDeleteSamplers(1, &sampler); 633 } 634 635 void get_sampler_parameterfv (NegativeTestContext& ctx) 636 { 637 float params = 0.0f; 638 GLuint sampler = 0; 639 ctx.glGenSamplers (1, &sampler); 640 641 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers."); 642 ctx.glGetSamplerParameterfv (-1, GL_TEXTURE_MAG_FILTER, ¶ms); 643 ctx.expectError (GL_INVALID_OPERATION); 644 ctx.endSection(); 645 646 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value."); 647 ctx.glGetSamplerParameterfv (sampler, -1, ¶ms); 648 ctx.expectError (GL_INVALID_ENUM); 649 ctx.endSection(); 650 651 ctx.glDeleteSamplers(1, &sampler); 652 } 653 654 void get_sampler_parameterIiv (NegativeTestContext& ctx) 655 { 656 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 657 throw tcu::NotSupportedError("glGetSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__); 658 659 GLuint sampler = 0x1234; 660 GLint borderColor = 0x1234; 661 662 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers."); 663 ctx.glGetSamplerParameterIiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor); 664 ctx.expectError(GL_INVALID_OPERATION); 665 ctx.endSection(); 666 667 ctx.glGenSamplers(1, &sampler); 668 669 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value."); 670 ctx.glGetSamplerParameterIiv(sampler, -1, &borderColor); 671 ctx.expectError(GL_INVALID_ENUM); 672 ctx.endSection(); 673 674 ctx.glDeleteSamplers(1, &sampler); 675 } 676 677 void get_sampler_parameterIuiv (NegativeTestContext& ctx) 678 { 679 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 680 throw tcu::NotSupportedError("glGetSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__); 681 682 GLuint sampler = 0x1234; 683 GLuint borderColor = 0x1234; 684 685 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers."); 686 ctx.glGetSamplerParameterIuiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor); 687 ctx.expectError(GL_INVALID_OPERATION); 688 ctx.endSection(); 689 690 ctx.glGenSamplers(1, &sampler); 691 692 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value."); 693 ctx.glGetSamplerParameterIuiv(sampler, -1, &borderColor); 694 ctx.expectError(GL_INVALID_ENUM); 695 ctx.endSection(); 696 697 ctx.glDeleteSamplers(1, &sampler); 698 } 699 700 void sampler_parameteri (NegativeTestContext& ctx) 701 { 702 GLuint sampler = 0; 703 704 ctx.glGenSamplers(1, &sampler); 705 706 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 707 ctx.glSamplerParameteri(-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 708 ctx.expectError(GL_INVALID_OPERATION); 709 ctx.endSection(); 710 711 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not."); 712 ctx.glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, -1); 713 ctx.expectError(GL_INVALID_ENUM); 714 ctx.endSection(); 715 716 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 717 { 718 ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameteri is called for a non-scalar parameter."); 719 ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0); 720 ctx.expectError(GL_INVALID_ENUM); 721 ctx.endSection(); 722 } 723 724 ctx.glDeleteSamplers(1, &sampler); 725 } 726 727 void sampler_parameteriv (NegativeTestContext& ctx) 728 { 729 int params = 0x1234; 730 GLuint sampler = 0; 731 ctx.glGenSamplers (1, &sampler); 732 733 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 734 params = GL_CLAMP_TO_EDGE; 735 ctx.glSamplerParameteriv (-1, GL_TEXTURE_WRAP_S, ¶ms); 736 ctx.expectError (GL_INVALID_OPERATION); 737 ctx.endSection(); 738 739 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not."); 740 params = -1; 741 ctx.glSamplerParameteriv (sampler, GL_TEXTURE_WRAP_S, ¶ms); 742 ctx.expectError (GL_INVALID_ENUM); 743 ctx.endSection(); 744 745 ctx.glDeleteSamplers(1, &sampler); 746 } 747 748 void sampler_parameterf (NegativeTestContext& ctx) 749 { 750 GLuint sampler = 0; 751 752 ctx.glGenSamplers(1, &sampler); 753 754 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 755 ctx.glSamplerParameterf(-1, GL_TEXTURE_MIN_LOD, -1000.0f); 756 ctx.expectError(GL_INVALID_OPERATION); 757 ctx.endSection(); 758 759 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not."); 760 ctx.glSamplerParameterf(sampler, GL_TEXTURE_WRAP_S, -1.0f); 761 ctx.expectError(GL_INVALID_ENUM); 762 ctx.endSection(); 763 764 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 765 { 766 ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameterf is called for a non-scalar parameter."); 767 ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0); 768 ctx.expectError(GL_INVALID_ENUM); 769 ctx.endSection(); 770 } 771 772 ctx.glDeleteSamplers(1, &sampler); 773 } 774 775 void sampler_parameterfv (NegativeTestContext& ctx) 776 { 777 float params; 778 GLuint sampler = 0; 779 ctx.glGenSamplers (1, &sampler); 780 781 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 782 params = -1000.0f; 783 ctx.glSamplerParameterfv (-1, GL_TEXTURE_WRAP_S, ¶ms); 784 ctx.expectError (GL_INVALID_OPERATION); 785 ctx.endSection(); 786 787 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not."); 788 params = -1.0f; 789 ctx.glSamplerParameterfv (sampler, GL_TEXTURE_WRAP_S, ¶ms); 790 ctx.expectError (GL_INVALID_ENUM); 791 ctx.endSection(); 792 793 ctx.glDeleteSamplers(1, &sampler); 794 } 795 796 void sampler_parameterIiv (NegativeTestContext& ctx) 797 { 798 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 799 throw tcu::NotSupportedError("glSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__); 800 801 GLuint sampler; 802 GLint color[] = {0, 0, 0, 0}; 803 804 ctx.glGenSamplers(1, &sampler); 805 806 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 807 ctx.glSamplerParameterIiv(-1, GL_TEXTURE_BORDER_COLOR, color); 808 ctx.expectError(GL_INVALID_OPERATION); 809 ctx.endSection(); 810 811 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name."); 812 ctx.glSamplerParameterIiv(sampler, -1, color); 813 ctx.expectError(GL_INVALID_ENUM); 814 ctx.endSection(); 815 } 816 817 void sampler_parameterIuiv (NegativeTestContext& ctx) 818 { 819 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 820 throw tcu::NotSupportedError("glSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__); 821 822 GLuint sampler; 823 GLuint color[] = {0, 0, 0, 0}; 824 825 ctx.glGenSamplers(1, &sampler); 826 827 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers."); 828 ctx.glSamplerParameterIuiv(-1, GL_TEXTURE_BORDER_COLOR, color); 829 ctx.expectError(GL_INVALID_OPERATION); 830 ctx.endSection(); 831 832 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name."); 833 ctx.glSamplerParameterIuiv(sampler, -1, color); 834 ctx.expectError(GL_INVALID_ENUM); 835 ctx.endSection(); 836 } 837 838 // Shader data commands 839 840 void get_attrib_location (NegativeTestContext& ctx) 841 { 842 GLuint programEmpty = ctx.glCreateProgram(); 843 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 844 845 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 846 847 const GLuint notAProgram = ctx.glCreateProgram(); 848 ctx.glDeleteProgram(notAProgram); 849 850 ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked."); 851 ctx.glBindAttribLocation (programEmpty, 0, "test"); 852 ctx.glGetAttribLocation (programEmpty, "test"); 853 ctx.expectError (GL_INVALID_OPERATION); 854 ctx.endSection(); 855 856 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a program or shader object."); 857 ctx.glUseProgram (program.getProgram()); 858 ctx.glBindAttribLocation (program.getProgram(), 0, "test"); 859 ctx.expectError (GL_NO_ERROR); 860 ctx.glGetAttribLocation (program.getProgram(), "test"); 861 ctx.expectError (GL_NO_ERROR); 862 ctx.glGetAttribLocation (notAProgram, "test"); 863 ctx.expectError (GL_INVALID_VALUE); 864 ctx.endSection(); 865 866 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 867 ctx.glGetAttribLocation (shader, "test"); 868 ctx.expectError (GL_INVALID_OPERATION); 869 ctx.endSection(); 870 871 ctx.glUseProgram (0); 872 ctx.glDeleteShader (shader); 873 ctx.glDeleteProgram (programEmpty); 874 } 875 876 void get_uniform_location (NegativeTestContext& ctx) 877 { 878 GLuint programEmpty = ctx.glCreateProgram(); 879 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 880 881 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 882 883 const GLuint notAProgram = ctx.glCreateProgram(); 884 ctx.glDeleteProgram(notAProgram); 885 886 ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked."); 887 ctx.glGetUniformLocation(programEmpty, "test"); 888 ctx.expectError(GL_INVALID_OPERATION); 889 ctx.endSection(); 890 891 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL."); 892 ctx.glUseProgram(program.getProgram()); 893 ctx.glGetUniformLocation(notAProgram, "test"); 894 ctx.expectError(GL_INVALID_VALUE); 895 ctx.endSection(); 896 897 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 898 ctx.glGetAttribLocation(shader, "test"); 899 ctx.expectError(GL_INVALID_OPERATION); 900 ctx.endSection(); 901 902 ctx.glUseProgram(0); 903 ctx.glDeleteProgram(programEmpty); 904 ctx.glDeleteShader(shader); 905 } 906 907 void bind_attrib_location (NegativeTestContext& ctx) 908 { 909 GLuint program = ctx.glCreateProgram(); 910 GLuint maxIndex = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 911 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 912 913 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 914 ctx.glBindAttribLocation(program, maxIndex, "test"); 915 ctx.expectError(GL_INVALID_VALUE); 916 ctx.endSection(); 917 918 ctx.beginSection("GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\"."); 919 ctx.glBindAttribLocation(program, maxIndex-1, "gl_test"); 920 ctx.expectError(GL_INVALID_OPERATION); 921 ctx.endSection(); 922 923 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL."); 924 ctx.glBindAttribLocation(-1, maxIndex-1, "test"); 925 ctx.expectError(GL_INVALID_VALUE); 926 ctx.endSection(); 927 928 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object."); 929 ctx.glBindAttribLocation(shader, maxIndex-1, "test"); 930 ctx.expectError(GL_INVALID_OPERATION); 931 ctx.endSection(); 932 933 ctx.glDeleteProgram(program); 934 ctx.glDeleteShader(shader); 935 } 936 937 void uniform_block_binding (NegativeTestContext& ctx) 938 { 939 GLint maxUniformBufferBindings = -1; 940 GLint numActiveUniforms = -1; 941 GLint numActiveBlocks = -1; 942 GLuint shader = -1; 943 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource)); 944 945 shader = ctx.glCreateShader(GL_VERTEX_SHADER); 946 ctx.glUseProgram(program.getProgram()); 947 948 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings); 949 ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms); 950 ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks); 951 ctx.getLog() << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings << TestLog::EndMessage; 952 ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << TestLog::EndMessage; 953 ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << TestLog::EndMessage; 954 ctx.expectError (GL_NO_ERROR); 955 956 ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program."); 957 ctx.glUniformBlockBinding(program.getProgram(), -1, 0); 958 ctx.expectError(GL_INVALID_VALUE); 959 ctx.glUniformBlockBinding(program.getProgram(), 5, 0); 960 ctx.expectError(GL_INVALID_VALUE); 961 ctx.endSection(); 962 963 ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockBinding is greater than or equal to the value of GL_MAX_UNIFORM_BUFFER_BINDINGS."); 964 ctx.glUniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0); 965 ctx.expectError(GL_INVALID_VALUE); 966 ctx.endSection(); 967 968 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object generated by the GL."); 969 ctx.glUniformBlockBinding(-1, 0, 0); 970 ctx.expectError(GL_INVALID_VALUE); 971 ctx.endSection(); 972 973 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object."); 974 ctx.glUniformBlockBinding(shader, 0, 0); 975 ctx.expectError(GL_INVALID_OPERATION); 976 ctx.endSection(); 977 978 ctx.glDeleteShader(shader); 979 } 980 981 // ctx.glUniform*f 982 983 void uniformf_invalid_program (NegativeTestContext& ctx) 984 { 985 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 986 ctx.glUseProgram(0); 987 ctx.glUniform1f(-1, 0.0f); 988 ctx.expectError(GL_INVALID_OPERATION); 989 ctx.glUniform2f(-1, 0.0f, 0.0f); 990 ctx.expectError(GL_INVALID_OPERATION); 991 ctx.glUniform3f(-1, 0.0f, 0.0f, 0.0f); 992 ctx.expectError(GL_INVALID_OPERATION); 993 ctx.glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f); 994 ctx.expectError(GL_INVALID_OPERATION); 995 ctx.endSection(); 996 } 997 998 void uniformf_incompatible_type (NegativeTestContext& ctx) 999 { 1000 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1001 1002 ctx.glUseProgram(program.getProgram()); 1003 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1004 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1005 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1006 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1007 ctx.expectError(GL_NO_ERROR); 1008 1009 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1010 { 1011 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1012 ctx.fail("Failed to retrieve uniform location"); 1013 } 1014 1015 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1016 ctx.glUseProgram(program.getProgram()); 1017 ctx.glUniform1f(vec4_v, 0.0f); 1018 ctx.expectError(GL_INVALID_OPERATION); 1019 ctx.glUniform2f(vec4_v, 0.0f, 0.0f); 1020 ctx.expectError(GL_INVALID_OPERATION); 1021 ctx.glUniform3f(vec4_v, 0.0f, 0.0f, 0.0f); 1022 ctx.expectError(GL_INVALID_OPERATION); 1023 ctx.glUniform4f(vec4_v, 0.0f, 0.0f, 0.0f, 0.0f); 1024 ctx.expectError(GL_NO_ERROR); 1025 ctx.endSection(); 1026 1027 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}f is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4."); 1028 ctx.glUseProgram(program.getProgram()); 1029 ctx.glUniform4f(ivec4_f, 0.0f, 0.0f, 0.0f, 0.0f); 1030 ctx.expectError(GL_INVALID_OPERATION); 1031 ctx.glUniform4f(uvec4_f, 0.0f, 0.0f, 0.0f, 0.0f); 1032 ctx.expectError(GL_INVALID_OPERATION); 1033 ctx.endSection(); 1034 1035 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv."); 1036 ctx.glUseProgram(program.getProgram()); 1037 ctx.glUniform1f(sampler_f, 0.0f); 1038 ctx.expectError(GL_INVALID_OPERATION); 1039 ctx.endSection(); 1040 1041 ctx.glUseProgram(0); 1042 } 1043 1044 void uniformf_invalid_location (NegativeTestContext& ctx) 1045 { 1046 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1047 1048 ctx.glUseProgram(program.getProgram()); 1049 ctx.expectError(GL_NO_ERROR); 1050 1051 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1052 ctx.glUseProgram(program.getProgram()); 1053 ctx.glUniform1f(-2, 0.0f); 1054 ctx.expectError(GL_INVALID_OPERATION); 1055 ctx.glUniform2f(-2, 0.0f, 0.0f); 1056 ctx.expectError(GL_INVALID_OPERATION); 1057 ctx.glUniform3f(-2, 0.0f, 0.0f, 0.0f); 1058 ctx.expectError(GL_INVALID_OPERATION); 1059 ctx.glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f); 1060 ctx.expectError(GL_INVALID_OPERATION); 1061 1062 ctx.glUseProgram(program.getProgram()); 1063 ctx.glUniform1f(-1, 0.0f); 1064 ctx.expectError(GL_NO_ERROR); 1065 ctx.glUniform2f(-1, 0.0f, 0.0f); 1066 ctx.expectError(GL_NO_ERROR); 1067 ctx.glUniform3f(-1, 0.0f, 0.0f, 0.0f); 1068 ctx.expectError(GL_NO_ERROR); 1069 ctx.glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f); 1070 ctx.expectError(GL_NO_ERROR); 1071 ctx.endSection(); 1072 1073 ctx.glUseProgram(0); 1074 } 1075 1076 // ctx.glUniform*fv 1077 1078 void uniformfv_invalid_program (NegativeTestContext& ctx) 1079 { 1080 std::vector<GLfloat> data(4); 1081 1082 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1083 ctx.glUseProgram(0); 1084 ctx.glUniform1fv(-1, 1, &data[0]); 1085 ctx.expectError(GL_INVALID_OPERATION); 1086 ctx.glUniform2fv(-1, 1, &data[0]); 1087 ctx.expectError(GL_INVALID_OPERATION); 1088 ctx.glUniform3fv(-1, 1, &data[0]); 1089 ctx.expectError(GL_INVALID_OPERATION); 1090 ctx.glUniform4fv(-1, 1, &data[0]); 1091 ctx.expectError(GL_INVALID_OPERATION); 1092 ctx.endSection(); 1093 } 1094 1095 void uniformfv_incompatible_type (NegativeTestContext& ctx) 1096 { 1097 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1098 1099 ctx.glUseProgram(program.getProgram()); 1100 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1101 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1102 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1103 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1104 ctx.expectError(GL_NO_ERROR); 1105 1106 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1107 { 1108 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1109 ctx.fail("Failed to retrieve uniform location"); 1110 } 1111 1112 std::vector<GLfloat> data(4); 1113 1114 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1115 ctx.glUseProgram(program.getProgram()); 1116 ctx.glUniform1fv(vec4_v, 1, &data[0]); 1117 ctx.expectError(GL_INVALID_OPERATION); 1118 ctx.glUniform2fv(vec4_v, 1, &data[0]); 1119 ctx.expectError(GL_INVALID_OPERATION); 1120 ctx.glUniform3fv(vec4_v, 1, &data[0]); 1121 ctx.expectError(GL_INVALID_OPERATION); 1122 ctx.glUniform4fv(vec4_v, 1, &data[0]); 1123 ctx.expectError(GL_NO_ERROR); 1124 ctx.endSection(); 1125 1126 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}fv is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4."); 1127 ctx.glUseProgram(program.getProgram()); 1128 ctx.glUniform4fv(ivec4_f, 1, &data[0]); 1129 ctx.expectError(GL_INVALID_OPERATION); 1130 ctx.glUniform4fv(uvec4_f, 1, &data[0]); 1131 ctx.expectError(GL_INVALID_OPERATION); 1132 ctx.endSection(); 1133 1134 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv."); 1135 ctx.glUseProgram(program.getProgram()); 1136 ctx.glUniform1fv(sampler_f, 1, &data[0]); 1137 ctx.expectError(GL_INVALID_OPERATION); 1138 ctx.endSection(); 1139 1140 ctx.glUseProgram(0); 1141 } 1142 1143 void uniformfv_invalid_location (NegativeTestContext& ctx) 1144 { 1145 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1146 1147 ctx.glUseProgram(program.getProgram()); 1148 ctx.expectError(GL_NO_ERROR); 1149 1150 std::vector<GLfloat> data(4); 1151 1152 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1153 ctx.glUseProgram(program.getProgram()); 1154 ctx.glUniform1fv(-2, 1, &data[0]); 1155 ctx.expectError(GL_INVALID_OPERATION); 1156 ctx.glUniform2fv(-2, 1, &data[0]); 1157 ctx.expectError(GL_INVALID_OPERATION); 1158 ctx.glUniform3fv(-2, 1, &data[0]); 1159 ctx.expectError(GL_INVALID_OPERATION); 1160 ctx.glUniform4fv(-2, 1, &data[0]); 1161 ctx.expectError(GL_INVALID_OPERATION); 1162 1163 ctx.glUseProgram(program.getProgram()); 1164 ctx.glUniform1fv(-1, 1, &data[0]); 1165 ctx.expectError(GL_NO_ERROR); 1166 ctx.glUniform2fv(-1, 1, &data[0]); 1167 ctx.expectError(GL_NO_ERROR); 1168 ctx.glUniform3fv(-1, 1, &data[0]); 1169 ctx.expectError(GL_NO_ERROR); 1170 ctx.glUniform4fv(-1, 1, &data[0]); 1171 ctx.expectError(GL_NO_ERROR); 1172 ctx.endSection(); 1173 1174 ctx.glUseProgram(0); 1175 } 1176 1177 void uniformfv_invalid_count (NegativeTestContext& ctx) 1178 { 1179 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1180 1181 ctx.glUseProgram (program.getProgram()); 1182 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1183 ctx.expectError(GL_NO_ERROR); 1184 1185 if (vec4_v == -1) 1186 { 1187 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1188 ctx.fail("Failed to retrieve uniform location"); 1189 } 1190 1191 std::vector<GLfloat> data(8); 1192 1193 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable."); 1194 ctx.glUseProgram(program.getProgram()); 1195 ctx.glUniform1fv(vec4_v, 2, &data[0]); 1196 ctx.expectError(GL_INVALID_OPERATION); 1197 ctx.glUniform2fv(vec4_v, 2, &data[0]); 1198 ctx.expectError(GL_INVALID_OPERATION); 1199 ctx.glUniform3fv(vec4_v, 2, &data[0]); 1200 ctx.expectError(GL_INVALID_OPERATION); 1201 ctx.glUniform4fv(vec4_v, 2, &data[0]); 1202 ctx.expectError(GL_INVALID_OPERATION); 1203 ctx.endSection(); 1204 1205 ctx.glUseProgram(0); 1206 } 1207 1208 // ctx.glUniform*i 1209 1210 void uniformi_invalid_program (NegativeTestContext& ctx) 1211 { 1212 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1213 ctx.glUseProgram(0); 1214 ctx.glUniform1i(-1, 0); 1215 ctx.expectError(GL_INVALID_OPERATION); 1216 ctx.glUniform2i(-1, 0, 0); 1217 ctx.expectError(GL_INVALID_OPERATION); 1218 ctx.glUniform3i(-1, 0, 0, 0); 1219 ctx.expectError(GL_INVALID_OPERATION); 1220 ctx.glUniform4i(-1, 0, 0, 0, 0); 1221 ctx.expectError(GL_INVALID_OPERATION); 1222 ctx.endSection(); 1223 } 1224 1225 void uniformi_incompatible_type (NegativeTestContext& ctx) 1226 { 1227 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1228 1229 ctx.glUseProgram(program.getProgram()); 1230 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1231 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1232 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1233 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1234 ctx.expectError(GL_NO_ERROR); 1235 1236 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1237 { 1238 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1239 ctx.fail("Failed to retrieve uniform location"); 1240 } 1241 1242 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1243 ctx.glUseProgram(program.getProgram()); 1244 ctx.glUniform1i(ivec4_f, 0); 1245 ctx.expectError(GL_INVALID_OPERATION); 1246 ctx.glUniform2i(ivec4_f, 0, 0); 1247 ctx.expectError(GL_INVALID_OPERATION); 1248 ctx.glUniform3i(ivec4_f, 0, 0, 0); 1249 ctx.expectError(GL_INVALID_OPERATION); 1250 ctx.glUniform4i(ivec4_f, 0, 0, 0, 0); 1251 ctx.expectError(GL_NO_ERROR); 1252 ctx.endSection(); 1253 1254 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type unsigned int, uvec2, uvec3, uvec4, or an array of these."); 1255 ctx.glUseProgram(program.getProgram()); 1256 ctx.glUniform1i(uvec4_f, 0); 1257 ctx.expectError(GL_INVALID_OPERATION); 1258 ctx.glUniform2i(uvec4_f, 0, 0); 1259 ctx.expectError(GL_INVALID_OPERATION); 1260 ctx.glUniform3i(uvec4_f, 0, 0, 0); 1261 ctx.expectError(GL_INVALID_OPERATION); 1262 ctx.glUniform4i(uvec4_f, 0, 0, 0, 0); 1263 ctx.expectError(GL_INVALID_OPERATION); 1264 ctx.endSection(); 1265 1266 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4."); 1267 ctx.glUseProgram(program.getProgram()); 1268 ctx.glUniform1i(vec4_v, 0); 1269 ctx.expectError(GL_INVALID_OPERATION); 1270 ctx.glUniform2i(vec4_v, 0, 0); 1271 ctx.expectError(GL_INVALID_OPERATION); 1272 ctx.glUniform3i(vec4_v, 0, 0, 0); 1273 ctx.expectError(GL_INVALID_OPERATION); 1274 ctx.glUniform4i(vec4_v, 0, 0, 0, 0); 1275 ctx.expectError(GL_INVALID_OPERATION); 1276 ctx.endSection(); 1277 1278 ctx.glUseProgram(0); 1279 } 1280 1281 void uniformi_invalid_location (NegativeTestContext& ctx) 1282 { 1283 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1284 1285 ctx.glUseProgram(program.getProgram()); 1286 ctx.expectError(GL_NO_ERROR); 1287 1288 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1289 ctx.glUseProgram(program.getProgram()); 1290 ctx.glUniform1i(-2, 0); 1291 ctx.expectError(GL_INVALID_OPERATION); 1292 ctx.glUniform2i(-2, 0, 0); 1293 ctx.expectError(GL_INVALID_OPERATION); 1294 ctx.glUniform3i(-2, 0, 0, 0); 1295 ctx.expectError(GL_INVALID_OPERATION); 1296 ctx.glUniform4i(-2, 0, 0, 0, 0); 1297 ctx.expectError(GL_INVALID_OPERATION); 1298 1299 ctx.glUseProgram(program.getProgram()); 1300 ctx.glUniform1i(-1, 0); 1301 ctx.expectError(GL_NO_ERROR); 1302 ctx.glUniform2i(-1, 0, 0); 1303 ctx.expectError(GL_NO_ERROR); 1304 ctx.glUniform3i(-1, 0, 0, 0); 1305 ctx.expectError(GL_NO_ERROR); 1306 ctx.glUniform4i(-1, 0, 0, 0, 0); 1307 ctx.expectError(GL_NO_ERROR); 1308 ctx.endSection(); 1309 1310 ctx.glUseProgram(0); 1311 } 1312 1313 // ctx.glUniform*iv 1314 1315 void uniformiv_invalid_program (NegativeTestContext& ctx) 1316 { 1317 std::vector<GLint> data(4); 1318 1319 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1320 ctx.glUseProgram(0); 1321 ctx.glUniform1iv(-1, 1, &data[0]); 1322 ctx.expectError(GL_INVALID_OPERATION); 1323 ctx.glUniform2iv(-1, 1, &data[0]); 1324 ctx.expectError(GL_INVALID_OPERATION); 1325 ctx.glUniform3iv(-1, 1, &data[0]); 1326 ctx.expectError(GL_INVALID_OPERATION); 1327 ctx.glUniform4iv(-1, 1, &data[0]); 1328 ctx.expectError(GL_INVALID_OPERATION); 1329 ctx.endSection(); 1330 } 1331 1332 void uniformiv_incompatible_type (NegativeTestContext& ctx) 1333 { 1334 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1335 1336 ctx.glUseProgram(program.getProgram()); 1337 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1338 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1339 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1340 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1341 ctx.expectError(GL_NO_ERROR); 1342 1343 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1344 { 1345 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1346 ctx.fail("Failed to retrieve uniform location"); 1347 } 1348 1349 std::vector<GLint> data(4); 1350 1351 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1352 ctx.glUseProgram(program.getProgram()); 1353 ctx.glUniform1iv(ivec4_f, 1, &data[0]); 1354 ctx.expectError(GL_INVALID_OPERATION); 1355 ctx.glUniform2iv(ivec4_f, 1, &data[0]); 1356 ctx.expectError(GL_INVALID_OPERATION); 1357 ctx.glUniform3iv(ivec4_f, 1, &data[0]); 1358 ctx.expectError(GL_INVALID_OPERATION); 1359 ctx.glUniform4iv(ivec4_f, 1, &data[0]); 1360 ctx.expectError(GL_NO_ERROR); 1361 ctx.endSection(); 1362 1363 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}iv is used to load a uniform variable of type float, vec2, vec3, or vec4."); 1364 ctx.glUseProgram(program.getProgram()); 1365 ctx.glUniform1iv(vec4_v, 1, &data[0]); 1366 ctx.expectError(GL_INVALID_OPERATION); 1367 ctx.glUniform2iv(vec4_v, 1, &data[0]); 1368 ctx.expectError(GL_INVALID_OPERATION); 1369 ctx.glUniform3iv(vec4_v, 1, &data[0]); 1370 ctx.expectError(GL_INVALID_OPERATION); 1371 ctx.glUniform4iv(vec4_v, 1, &data[0]); 1372 ctx.expectError(GL_INVALID_OPERATION); 1373 ctx.endSection(); 1374 1375 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}iv is used to load a uniform variable of type unsigned int, uvec2, uvec3 or uvec4."); 1376 ctx.glUseProgram(program.getProgram()); 1377 ctx.glUniform1iv(uvec4_f, 1, &data[0]); 1378 ctx.expectError(GL_INVALID_OPERATION); 1379 ctx.glUniform2iv(uvec4_f, 1, &data[0]); 1380 ctx.expectError(GL_INVALID_OPERATION); 1381 ctx.glUniform3iv(uvec4_f, 1, &data[0]); 1382 ctx.expectError(GL_INVALID_OPERATION); 1383 ctx.glUniform4iv(uvec4_f, 1, &data[0]); 1384 ctx.expectError(GL_INVALID_OPERATION); 1385 ctx.endSection(); 1386 1387 ctx.glUseProgram(0); 1388 } 1389 1390 void uniformiv_invalid_location (NegativeTestContext& ctx) 1391 { 1392 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1393 1394 ctx.glUseProgram(program.getProgram()); 1395 ctx.expectError(GL_NO_ERROR); 1396 1397 std::vector<GLint> data(4); 1398 1399 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1400 ctx.glUseProgram(program.getProgram()); 1401 ctx.glUniform1iv(-2, 1, &data[0]); 1402 ctx.expectError(GL_INVALID_OPERATION); 1403 ctx.glUniform2iv(-2, 1, &data[0]); 1404 ctx.expectError(GL_INVALID_OPERATION); 1405 ctx.glUniform3iv(-2, 1, &data[0]); 1406 ctx.expectError(GL_INVALID_OPERATION); 1407 ctx.glUniform4iv(-2, 1, &data[0]); 1408 ctx.expectError(GL_INVALID_OPERATION); 1409 1410 ctx.glUseProgram(program.getProgram()); 1411 ctx.glUniform1iv(-1, 1, &data[0]); 1412 ctx.expectError(GL_NO_ERROR); 1413 ctx.glUniform2iv(-1, 1, &data[0]); 1414 ctx.expectError(GL_NO_ERROR); 1415 ctx.glUniform3iv(-1, 1, &data[0]); 1416 ctx.expectError(GL_NO_ERROR); 1417 ctx.glUniform4iv(-1, 1, &data[0]); 1418 ctx.expectError(GL_NO_ERROR); 1419 ctx.endSection(); 1420 1421 ctx.glUseProgram(0); 1422 } 1423 1424 void uniformiv_invalid_count (NegativeTestContext& ctx) 1425 { 1426 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1427 1428 ctx.glUseProgram (program.getProgram()); 1429 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1430 ctx.expectError(GL_NO_ERROR); 1431 1432 if (ivec4_f == -1) 1433 { 1434 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1435 ctx.fail("Failed to retrieve uniform location"); 1436 } 1437 1438 std::vector<GLint> data(8); 1439 1440 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable."); 1441 ctx.glUseProgram(program.getProgram()); 1442 ctx.glUniform1iv(ivec4_f, 2, &data[0]); 1443 ctx.expectError(GL_INVALID_OPERATION); 1444 ctx.glUniform2iv(ivec4_f, 2, &data[0]); 1445 ctx.expectError(GL_INVALID_OPERATION); 1446 ctx.glUniform3iv(ivec4_f, 2, &data[0]); 1447 ctx.expectError(GL_INVALID_OPERATION); 1448 ctx.glUniform4iv(ivec4_f, 2, &data[0]); 1449 ctx.expectError(GL_INVALID_OPERATION); 1450 ctx.endSection(); 1451 1452 ctx.glUseProgram(0); 1453 } 1454 1455 // ctx.glUniform{1234}ui 1456 1457 void uniformui_invalid_program (NegativeTestContext& ctx) 1458 { 1459 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1460 ctx.glUseProgram(0); 1461 ctx.glUniform1ui(-1, 0); 1462 ctx.expectError(GL_INVALID_OPERATION); 1463 ctx.glUniform2ui(-1, 0, 0); 1464 ctx.expectError(GL_INVALID_OPERATION); 1465 ctx.glUniform3ui(-1, 0, 0, 0); 1466 ctx.expectError(GL_INVALID_OPERATION); 1467 ctx.glUniform4ui(-1, 0, 0, 0, 0); 1468 ctx.expectError(GL_INVALID_OPERATION); 1469 ctx.endSection(); 1470 } 1471 1472 void uniformui_incompatible_type (NegativeTestContext& ctx) 1473 { 1474 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1475 1476 ctx.glUseProgram(program.getProgram()); 1477 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1478 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1479 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1480 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1481 ctx.expectError(GL_NO_ERROR); 1482 1483 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1484 { 1485 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1486 ctx.fail("Failed to retrieve uniform location"); 1487 } 1488 1489 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1490 ctx.glUseProgram(program.getProgram()); 1491 ctx.glUniform1ui(uvec4_f, 0); 1492 ctx.expectError(GL_INVALID_OPERATION); 1493 ctx.glUniform2ui(uvec4_f, 0, 0); 1494 ctx.expectError(GL_INVALID_OPERATION); 1495 ctx.glUniform3ui(uvec4_f, 0, 0, 0); 1496 ctx.expectError(GL_INVALID_OPERATION); 1497 ctx.glUniform4ui(uvec4_f, 0, 0, 0, 0); 1498 ctx.expectError(GL_NO_ERROR); 1499 ctx.endSection(); 1500 1501 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type int, ivec2, ivec3, ivec4, or an array of these."); 1502 ctx.glUseProgram(program.getProgram()); 1503 ctx.glUniform1ui(ivec4_f, 0); 1504 ctx.expectError(GL_INVALID_OPERATION); 1505 ctx.glUniform2ui(ivec4_f, 0, 0); 1506 ctx.expectError(GL_INVALID_OPERATION); 1507 ctx.glUniform3ui(ivec4_f, 0, 0, 0); 1508 ctx.expectError(GL_INVALID_OPERATION); 1509 ctx.glUniform4ui(ivec4_f, 0, 0, 0, 0); 1510 ctx.expectError(GL_INVALID_OPERATION); 1511 ctx.endSection(); 1512 1513 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4."); 1514 ctx.glUseProgram(program.getProgram()); 1515 ctx.glUniform1ui(vec4_v, 0); 1516 ctx.expectError(GL_INVALID_OPERATION); 1517 ctx.glUniform2ui(vec4_v, 0, 0); 1518 ctx.expectError(GL_INVALID_OPERATION); 1519 ctx.glUniform3ui(vec4_v, 0, 0, 0); 1520 ctx.expectError(GL_INVALID_OPERATION); 1521 ctx.glUniform4ui(vec4_v, 0, 0, 0, 0); 1522 ctx.expectError(GL_INVALID_OPERATION); 1523 ctx.endSection(); 1524 1525 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv."); 1526 ctx.glUseProgram(program.getProgram()); 1527 ctx.glUniform1ui(sampler_f, 0); 1528 ctx.expectError(GL_INVALID_OPERATION); 1529 ctx.endSection(); 1530 1531 ctx.glUseProgram(0); 1532 } 1533 1534 void uniformui_invalid_location (NegativeTestContext& ctx) 1535 { 1536 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1537 1538 ctx.glUseProgram(program.getProgram()); 1539 ctx.expectError(GL_NO_ERROR); 1540 1541 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1542 ctx.glUseProgram(program.getProgram()); 1543 ctx.glUniform1i(-2, 0); 1544 ctx.expectError(GL_INVALID_OPERATION); 1545 ctx.glUniform2i(-2, 0, 0); 1546 ctx.expectError(GL_INVALID_OPERATION); 1547 ctx.glUniform3i(-2, 0, 0, 0); 1548 ctx.expectError(GL_INVALID_OPERATION); 1549 ctx.glUniform4i(-2, 0, 0, 0, 0); 1550 ctx.expectError(GL_INVALID_OPERATION); 1551 1552 ctx.glUseProgram(program.getProgram()); 1553 ctx.glUniform1i(-1, 0); 1554 ctx.expectError(GL_NO_ERROR); 1555 ctx.glUniform2i(-1, 0, 0); 1556 ctx.expectError(GL_NO_ERROR); 1557 ctx.glUniform3i(-1, 0, 0, 0); 1558 ctx.expectError(GL_NO_ERROR); 1559 ctx.glUniform4i(-1, 0, 0, 0, 0); 1560 ctx.expectError(GL_NO_ERROR); 1561 ctx.endSection(); 1562 1563 ctx.glUseProgram(0); 1564 } 1565 1566 // ctx.glUniform{1234}uiv 1567 1568 void uniformuiv_invalid_program (NegativeTestContext& ctx) 1569 { 1570 std::vector<GLuint> data(4); 1571 1572 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1573 ctx.glUseProgram(0); 1574 ctx.glUniform1uiv(-1, 1, &data[0]); 1575 ctx.expectError(GL_INVALID_OPERATION); 1576 ctx.glUniform2uiv(-1, 1, &data[0]); 1577 ctx.expectError(GL_INVALID_OPERATION); 1578 ctx.glUniform3uiv(-1, 1, &data[0]); 1579 ctx.expectError(GL_INVALID_OPERATION); 1580 ctx.glUniform4uiv(-1, 1, &data[0]); 1581 ctx.expectError(GL_INVALID_OPERATION); 1582 ctx.endSection(); 1583 } 1584 1585 void uniformuiv_incompatible_type (NegativeTestContext& ctx) 1586 { 1587 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1588 1589 ctx.glUseProgram(program.getProgram()); 1590 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4 1591 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4 1592 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1593 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1594 ctx.expectError(GL_NO_ERROR); 1595 1596 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1) 1597 { 1598 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1599 ctx.fail("Failed to retrieve uniform location"); 1600 } 1601 1602 std::vector<GLuint> data(4); 1603 1604 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1605 ctx.glUseProgram(program.getProgram()); 1606 ctx.glUniform1uiv(uvec4_f, 1, &data[0]); 1607 ctx.expectError(GL_INVALID_OPERATION); 1608 ctx.glUniform2uiv(uvec4_f, 1, &data[0]); 1609 ctx.expectError(GL_INVALID_OPERATION); 1610 ctx.glUniform3uiv(uvec4_f, 1, &data[0]); 1611 ctx.expectError(GL_INVALID_OPERATION); 1612 ctx.glUniform4uiv(uvec4_f, 1, &data[0]); 1613 ctx.expectError(GL_NO_ERROR); 1614 ctx.endSection(); 1615 1616 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}uiv is used to load a uniform variable of type float, vec2, vec3, or vec4."); 1617 ctx.glUseProgram(program.getProgram()); 1618 ctx.glUniform1uiv(vec4_v, 1, &data[0]); 1619 ctx.expectError(GL_INVALID_OPERATION); 1620 ctx.glUniform2uiv(vec4_v, 1, &data[0]); 1621 ctx.expectError(GL_INVALID_OPERATION); 1622 ctx.glUniform3uiv(vec4_v, 1, &data[0]); 1623 ctx.expectError(GL_INVALID_OPERATION); 1624 ctx.glUniform4uiv(vec4_v, 1, &data[0]); 1625 ctx.expectError(GL_INVALID_OPERATION); 1626 ctx.endSection(); 1627 1628 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}uiv is used to load a uniform variable of type int, ivec2, ivec3 or ivec4."); 1629 ctx.glUseProgram(program.getProgram()); 1630 ctx.glUniform1uiv(ivec4_f, 1, &data[0]); 1631 ctx.expectError(GL_INVALID_OPERATION); 1632 ctx.glUniform2uiv(ivec4_f, 1, &data[0]); 1633 ctx.expectError(GL_INVALID_OPERATION); 1634 ctx.glUniform3uiv(ivec4_f, 1, &data[0]); 1635 ctx.expectError(GL_INVALID_OPERATION); 1636 ctx.glUniform4uiv(ivec4_f, 1, &data[0]); 1637 ctx.expectError(GL_INVALID_OPERATION); 1638 ctx.endSection(); 1639 1640 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv."); 1641 ctx.glUseProgram(program.getProgram()); 1642 ctx.glUniform1uiv(sampler_f, 1, &data[0]); 1643 ctx.expectError(GL_INVALID_OPERATION); 1644 ctx.endSection(); 1645 1646 ctx.glUseProgram(0); 1647 } 1648 1649 void uniformuiv_invalid_location (NegativeTestContext& ctx) 1650 { 1651 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1652 1653 ctx.glUseProgram(program.getProgram()); 1654 ctx.expectError(GL_NO_ERROR); 1655 1656 std::vector<GLuint> data(4); 1657 1658 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1659 ctx.glUseProgram(program.getProgram()); 1660 ctx.glUniform1uiv(-2, 1, &data[0]); 1661 ctx.expectError(GL_INVALID_OPERATION); 1662 ctx.glUniform2uiv(-2, 1, &data[0]); 1663 ctx.expectError(GL_INVALID_OPERATION); 1664 ctx.glUniform3uiv(-2, 1, &data[0]); 1665 ctx.expectError(GL_INVALID_OPERATION); 1666 ctx.glUniform4uiv(-2, 1, &data[0]); 1667 ctx.expectError(GL_INVALID_OPERATION); 1668 1669 ctx.glUseProgram(program.getProgram()); 1670 ctx.glUniform1uiv(-1, 1, &data[0]); 1671 ctx.expectError(GL_NO_ERROR); 1672 ctx.glUniform2uiv(-1, 1, &data[0]); 1673 ctx.expectError(GL_NO_ERROR); 1674 ctx.glUniform3uiv(-1, 1, &data[0]); 1675 ctx.expectError(GL_NO_ERROR); 1676 ctx.glUniform4uiv(-1, 1, &data[0]); 1677 ctx.expectError(GL_NO_ERROR); 1678 ctx.endSection(); 1679 1680 ctx.glUseProgram(0); 1681 } 1682 1683 void uniformuiv_invalid_count (NegativeTestContext& ctx) 1684 { 1685 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1686 1687 ctx.glUseProgram (program.getProgram()); 1688 int uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4 1689 ctx.expectError(GL_NO_ERROR); 1690 1691 if (uvec4_f == -1) 1692 { 1693 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1694 ctx.fail("Failed to retrieve uniform location"); 1695 } 1696 1697 std::vector<GLuint> data(8); 1698 1699 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable."); 1700 ctx.glUseProgram(program.getProgram()); 1701 ctx.glUniform1uiv(uvec4_f, 2, &data[0]); 1702 ctx.expectError(GL_INVALID_OPERATION); 1703 ctx.glUniform2uiv(uvec4_f, 2, &data[0]); 1704 ctx.expectError(GL_INVALID_OPERATION); 1705 ctx.glUniform3uiv(uvec4_f, 2, &data[0]); 1706 ctx.expectError(GL_INVALID_OPERATION); 1707 ctx.glUniform4uiv(uvec4_f, 2, &data[0]); 1708 ctx.expectError(GL_INVALID_OPERATION); 1709 ctx.endSection(); 1710 1711 ctx.glUseProgram(0); 1712 } 1713 1714 1715 // ctx.glUniformMatrix*fv 1716 1717 void uniform_matrixfv_invalid_program (NegativeTestContext& ctx) 1718 { 1719 std::vector<GLfloat> data(16); 1720 1721 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object."); 1722 ctx.glUseProgram(0); 1723 ctx.glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]); 1724 ctx.expectError(GL_INVALID_OPERATION); 1725 ctx.glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]); 1726 ctx.expectError(GL_INVALID_OPERATION); 1727 ctx.glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]); 1728 ctx.expectError(GL_INVALID_OPERATION); 1729 1730 ctx.glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]); 1731 ctx.expectError(GL_INVALID_OPERATION); 1732 ctx.glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]); 1733 ctx.expectError(GL_INVALID_OPERATION); 1734 ctx.glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]); 1735 ctx.expectError(GL_INVALID_OPERATION); 1736 ctx.glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]); 1737 ctx.expectError(GL_INVALID_OPERATION); 1738 ctx.glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]); 1739 ctx.expectError(GL_INVALID_OPERATION); 1740 ctx.glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]); 1741 ctx.expectError(GL_INVALID_OPERATION); 1742 ctx.endSection(); 1743 } 1744 1745 void uniform_matrixfv_incompatible_type (NegativeTestContext& ctx) 1746 { 1747 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1748 1749 ctx.glUseProgram (program.getProgram()); 1750 GLint mat4_v = ctx.glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4 1751 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D 1752 ctx.expectError(GL_NO_ERROR); 1753 1754 if (mat4_v == -1 || sampler_f == -1) 1755 { 1756 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1757 ctx.fail("Failed to retrieve uniform location"); 1758 } 1759 1760 std::vector<GLfloat> data(16); 1761 1762 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command."); 1763 ctx.glUseProgram(program.getProgram()); 1764 ctx.glUniformMatrix2fv(mat4_v, 1, GL_FALSE, &data[0]); 1765 ctx.expectError(GL_INVALID_OPERATION); 1766 ctx.glUniformMatrix3fv(mat4_v, 1, GL_FALSE, &data[0]); 1767 ctx.expectError(GL_INVALID_OPERATION); 1768 ctx.glUniformMatrix4fv(mat4_v, 1, GL_FALSE, &data[0]); 1769 ctx.expectError(GL_NO_ERROR); 1770 1771 ctx.glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]); 1772 ctx.expectError(GL_INVALID_OPERATION); 1773 ctx.glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]); 1774 ctx.expectError(GL_INVALID_OPERATION); 1775 ctx.glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]); 1776 ctx.expectError(GL_INVALID_OPERATION); 1777 ctx.glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]); 1778 ctx.expectError(GL_INVALID_OPERATION); 1779 ctx.glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]); 1780 ctx.expectError(GL_INVALID_OPERATION); 1781 ctx.glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]); 1782 ctx.expectError(GL_INVALID_OPERATION); 1783 ctx.endSection(); 1784 1785 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv."); 1786 ctx.glUseProgram(program.getProgram()); 1787 ctx.glUniformMatrix2fv(sampler_f, 1, GL_FALSE, &data[0]); 1788 ctx.expectError(GL_INVALID_OPERATION); 1789 ctx.glUniformMatrix3fv(sampler_f, 1, GL_FALSE, &data[0]); 1790 ctx.expectError(GL_INVALID_OPERATION); 1791 ctx.glUniformMatrix4fv(sampler_f, 1, GL_FALSE, &data[0]); 1792 ctx.expectError(GL_INVALID_OPERATION); 1793 1794 ctx.glUniformMatrix2x3fv(sampler_f, 1, GL_FALSE, &data[0]); 1795 ctx.expectError(GL_INVALID_OPERATION); 1796 ctx.glUniformMatrix3x2fv(sampler_f, 1, GL_FALSE, &data[0]); 1797 ctx.expectError(GL_INVALID_OPERATION); 1798 ctx.glUniformMatrix2x4fv(sampler_f, 1, GL_FALSE, &data[0]); 1799 ctx.expectError(GL_INVALID_OPERATION); 1800 ctx.glUniformMatrix4x2fv(sampler_f, 1, GL_FALSE, &data[0]); 1801 ctx.expectError(GL_INVALID_OPERATION); 1802 ctx.glUniformMatrix3x4fv(sampler_f, 1, GL_FALSE, &data[0]); 1803 ctx.expectError(GL_INVALID_OPERATION); 1804 ctx.glUniformMatrix4x3fv(sampler_f, 1, GL_FALSE, &data[0]); 1805 ctx.expectError(GL_INVALID_OPERATION); 1806 ctx.endSection(); 1807 1808 ctx.glUseProgram(0); 1809 } 1810 1811 void uniform_matrixfv_invalid_location (NegativeTestContext& ctx) 1812 { 1813 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1814 1815 ctx.glUseProgram(program.getProgram()); 1816 ctx.expectError(GL_NO_ERROR); 1817 1818 std::vector<GLfloat> data(16); 1819 1820 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1."); 1821 ctx.glUseProgram(program.getProgram()); 1822 ctx.glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]); 1823 ctx.expectError(GL_INVALID_OPERATION); 1824 ctx.glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]); 1825 ctx.expectError(GL_INVALID_OPERATION); 1826 ctx.glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]); 1827 ctx.expectError(GL_INVALID_OPERATION); 1828 1829 ctx.glUniformMatrix2x3fv(-2, 1, GL_FALSE, &data[0]); 1830 ctx.expectError(GL_INVALID_OPERATION); 1831 ctx.glUniformMatrix3x2fv(-2, 1, GL_FALSE, &data[0]); 1832 ctx.expectError(GL_INVALID_OPERATION); 1833 ctx.glUniformMatrix2x4fv(-2, 1, GL_FALSE, &data[0]); 1834 ctx.expectError(GL_INVALID_OPERATION); 1835 ctx.glUniformMatrix4x2fv(-2, 1, GL_FALSE, &data[0]); 1836 ctx.expectError(GL_INVALID_OPERATION); 1837 ctx.glUniformMatrix3x4fv(-2, 1, GL_FALSE, &data[0]); 1838 ctx.expectError(GL_INVALID_OPERATION); 1839 ctx.glUniformMatrix4x3fv(-2, 1, GL_FALSE, &data[0]); 1840 ctx.expectError(GL_INVALID_OPERATION); 1841 1842 ctx.glUseProgram(program.getProgram()); 1843 ctx.glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]); 1844 ctx.expectError(GL_NO_ERROR); 1845 ctx.glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]); 1846 ctx.expectError(GL_NO_ERROR); 1847 ctx.glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]); 1848 ctx.expectError(GL_NO_ERROR); 1849 1850 ctx.glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]); 1851 ctx.expectError(GL_NO_ERROR); 1852 ctx.glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]); 1853 ctx.expectError(GL_NO_ERROR); 1854 ctx.glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]); 1855 ctx.expectError(GL_NO_ERROR); 1856 ctx.glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]); 1857 ctx.expectError(GL_NO_ERROR); 1858 ctx.glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]); 1859 ctx.expectError(GL_NO_ERROR); 1860 ctx.glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]); 1861 ctx.expectError(GL_NO_ERROR); 1862 ctx.endSection(); 1863 1864 ctx.glUseProgram(0); 1865 } 1866 1867 void uniform_matrixfv_invalid_count (NegativeTestContext& ctx) 1868 { 1869 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource)); 1870 1871 ctx.glUseProgram (program.getProgram()); 1872 GLint mat4_v = ctx.glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4 1873 ctx.expectError(GL_NO_ERROR); 1874 1875 if (mat4_v == -1) 1876 { 1877 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage; 1878 ctx.fail("Failed to retrieve uniform location"); 1879 } 1880 1881 std::vector<GLfloat> data(32); 1882 1883 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable."); 1884 ctx.glUseProgram(program.getProgram()); 1885 ctx.glUniformMatrix2fv(mat4_v, 2, GL_FALSE, &data[0]); 1886 ctx.expectError(GL_INVALID_OPERATION); 1887 ctx.glUniformMatrix3fv(mat4_v, 2, GL_FALSE, &data[0]); 1888 ctx.expectError(GL_INVALID_OPERATION); 1889 ctx.glUniformMatrix4fv(mat4_v, 2, GL_FALSE, &data[0]); 1890 ctx.expectError(GL_INVALID_OPERATION); 1891 1892 ctx.glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]); 1893 ctx.expectError(GL_INVALID_OPERATION); 1894 ctx.glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]); 1895 ctx.expectError(GL_INVALID_OPERATION); 1896 ctx.glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]); 1897 ctx.expectError(GL_INVALID_OPERATION); 1898 ctx.glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]); 1899 ctx.expectError(GL_INVALID_OPERATION); 1900 ctx.glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]); 1901 ctx.expectError(GL_INVALID_OPERATION); 1902 ctx.glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]); 1903 ctx.expectError(GL_INVALID_OPERATION); 1904 ctx.endSection(); 1905 1906 ctx.glUseProgram(0); 1907 } 1908 1909 // Transform feedback 1910 void gen_transform_feedbacks (NegativeTestContext& ctx) 1911 { 1912 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1913 GLuint id = 0; 1914 ctx.glGenTransformFeedbacks(-1, &id); 1915 ctx.expectError(GL_INVALID_VALUE); 1916 ctx.endSection(); 1917 } 1918 1919 void bind_transform_feedback (NegativeTestContext& ctx) 1920 { 1921 GLuint tfID[2]; 1922 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 1923 deUint32 buf = 0x1234; 1924 const char* tfVarying = "gl_Position"; 1925 1926 ctx.glGenBuffers (1, &buf); 1927 ctx.glGenTransformFeedbacks (2, tfID); 1928 1929 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK."); 1930 ctx.glBindTransformFeedback(-1, tfID[0]); 1931 ctx.expectError(GL_INVALID_ENUM); 1932 ctx.endSection(); 1933 1934 ctx.beginSection("GL_INVALID_OPERATION is generated if the transform feedback operation is active on the currently bound transform feedback object, and is not paused."); 1935 ctx.glUseProgram (program.getProgram()); 1936 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 1937 ctx.glLinkProgram (program.getProgram()); 1938 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]); 1939 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 1940 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 1941 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 1942 ctx.glBeginTransformFeedback (GL_TRIANGLES); 1943 ctx.expectError (GL_NO_ERROR); 1944 1945 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[1]); 1946 ctx.expectError (GL_INVALID_OPERATION); 1947 1948 ctx.glEndTransformFeedback (); 1949 ctx.expectError (GL_NO_ERROR); 1950 ctx.endSection(); 1951 1952 ctx.glUseProgram (0); 1953 ctx.glDeleteBuffers (1, &buf); 1954 ctx.glDeleteTransformFeedbacks (2, tfID); 1955 ctx.expectError (GL_NO_ERROR); 1956 1957 ctx.beginSection("GL_INVALID_OPERATION is generated if id has been deleted with glDeleteTransformFeedback()."); 1958 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]); 1959 ctx.expectError(GL_INVALID_OPERATION); 1960 ctx.endSection(); 1961 1962 ctx.beginSection("GL_INVALID_OPERATION is generated if id is not 0 or a value returned from glGenTransformFeedbacks()."); 1963 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, -1); 1964 ctx.expectError(GL_INVALID_OPERATION); 1965 ctx.endSection(); 1966 } 1967 1968 void delete_transform_feedbacks (NegativeTestContext& ctx) 1969 { 1970 GLuint id = 0; 1971 GLuint tfID[2]; 1972 deUint32 buf = 0x1234; 1973 const char* tfVarying = "gl_Position"; 1974 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 1975 1976 ctx.glGenBuffers(1, &buf); 1977 ctx.glGenTransformFeedbacks(1, &id); 1978 ctx.glGenTransformFeedbacks(2, tfID); 1979 1980 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1981 ctx.glDeleteTransformFeedbacks(-1, &id); 1982 ctx.expectError(GL_INVALID_VALUE); 1983 ctx.endSection(); 1984 1985 ctx.beginSection("GL_INVALID_OPERATION is generated if the transform feedback operation for any object named by ids is currently active."); 1986 ctx.glUseProgram(program.getProgram()); 1987 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 1988 ctx.glLinkProgram(program.getProgram()); 1989 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]); 1990 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 1991 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 1992 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 1993 ctx.glBeginTransformFeedback(GL_TRIANGLES); 1994 ctx.expectError(GL_NO_ERROR); 1995 1996 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[1]); 1997 ctx.expectError(GL_INVALID_OPERATION); 1998 1999 ctx.glDeleteTransformFeedbacks(2, tfID); 2000 ctx.expectError(GL_INVALID_OPERATION); 2001 2002 ctx.glEndTransformFeedback(); 2003 ctx.expectError(GL_NO_ERROR); 2004 ctx.endSection(); 2005 2006 2007 ctx.glDeleteTransformFeedbacks(1, &id); 2008 ctx.glDeleteTransformFeedbacks(2, tfID); 2009 ctx.glDeleteBuffers(1, &buf); 2010 2011 } 2012 2013 void begin_transform_feedback (NegativeTestContext& ctx) 2014 { 2015 GLuint tfID[2]; 2016 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2017 deUint32 buf = 0x1234; 2018 const char* tfVarying = "gl_Position"; 2019 2020 ctx.glGenBuffers (1, &buf); 2021 ctx.glGenTransformFeedbacks (2, tfID); 2022 2023 ctx.glUseProgram (program.getProgram()); 2024 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2025 ctx.glLinkProgram (program.getProgram()); 2026 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]); 2027 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 2028 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 2029 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 2030 ctx.expectError (GL_NO_ERROR); 2031 2032 ctx.beginSection("GL_INVALID_ENUM is generated if primitiveMode is not one of GL_POINTS, GL_LINES, or GL_TRIANGLES."); 2033 ctx.glBeginTransformFeedback (-1); 2034 ctx.expectError (GL_INVALID_ENUM); 2035 ctx.endSection(); 2036 2037 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is already active."); 2038 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2039 ctx.expectError (GL_NO_ERROR); 2040 ctx.glBeginTransformFeedback (GL_POINTS); 2041 ctx.expectError (GL_INVALID_OPERATION); 2042 ctx.endSection(); 2043 2044 ctx.beginSection("GL_INVALID_OPERATION is generated if any binding point used in transform feedback mode does not have a buffer object bound."); 2045 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); 2046 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2047 ctx.expectError (GL_INVALID_OPERATION); 2048 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 2049 ctx.endSection(); 2050 2051 ctx.beginSection("GL_INVALID_OPERATION is generated if no binding points would be used because no program object is active."); 2052 ctx.glUseProgram (0); 2053 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2054 ctx.expectError (GL_INVALID_OPERATION); 2055 ctx.glUseProgram (program.getProgram()); 2056 ctx.endSection(); 2057 2058 ctx.beginSection("GL_INVALID_OPERATION is generated if no binding points would be used because the active program object has specified no varying variables to record."); 2059 ctx.glTransformFeedbackVaryings (program.getProgram(), 0, 0, GL_INTERLEAVED_ATTRIBS); 2060 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2061 ctx.expectError (GL_INVALID_OPERATION); 2062 ctx.endSection(); 2063 2064 ctx.glEndTransformFeedback (); 2065 ctx.glDeleteBuffers (1, &buf); 2066 ctx.glDeleteTransformFeedbacks (2, tfID); 2067 ctx.expectError (GL_NO_ERROR); 2068 } 2069 2070 void pause_transform_feedback (NegativeTestContext& ctx) 2071 { 2072 GLuint tfID[2]; 2073 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2074 deUint32 buf = 0x1234; 2075 const char* tfVarying = "gl_Position"; 2076 2077 ctx.glGenBuffers (1, &buf); 2078 ctx.glGenTransformFeedbacks (2, tfID); 2079 2080 ctx.glUseProgram (program.getProgram()); 2081 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2082 ctx.glLinkProgram (program.getProgram()); 2083 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]); 2084 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 2085 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 2086 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 2087 ctx.expectError (GL_NO_ERROR); 2088 2089 ctx.beginSection("GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is paused."); 2090 ctx.glPauseTransformFeedback (); 2091 ctx.expectError (GL_INVALID_OPERATION); 2092 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2093 ctx.glPauseTransformFeedback (); 2094 ctx.expectError (GL_NO_ERROR); 2095 ctx.glPauseTransformFeedback (); 2096 ctx.expectError (GL_INVALID_OPERATION); 2097 ctx.endSection(); 2098 2099 ctx.glEndTransformFeedback (); 2100 ctx.glDeleteBuffers (1, &buf); 2101 ctx.glDeleteTransformFeedbacks (2, tfID); 2102 ctx.expectError (GL_NO_ERROR); 2103 } 2104 2105 void resume_transform_feedback (NegativeTestContext& ctx) 2106 { 2107 GLuint tfID[2]; 2108 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2109 deUint32 buf = 0x1234; 2110 const char* tfVarying = "gl_Position"; 2111 2112 ctx.glGenBuffers (1, &buf); 2113 ctx.glGenTransformFeedbacks (2, tfID); 2114 2115 ctx.glUseProgram (program.getProgram()); 2116 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2117 ctx.glLinkProgram (program.getProgram()); 2118 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]); 2119 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 2120 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 2121 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 2122 ctx.expectError (GL_NO_ERROR); 2123 2124 ctx.beginSection("GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is not paused."); 2125 ctx.glResumeTransformFeedback (); 2126 ctx.expectError (GL_INVALID_OPERATION); 2127 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2128 ctx.glResumeTransformFeedback (); 2129 ctx.expectError (GL_INVALID_OPERATION); 2130 ctx.glPauseTransformFeedback (); 2131 ctx.glResumeTransformFeedback (); 2132 ctx.expectError (GL_NO_ERROR); 2133 ctx.endSection(); 2134 2135 ctx.glEndTransformFeedback (); 2136 ctx.glDeleteBuffers (1, &buf); 2137 ctx.glDeleteTransformFeedbacks (2, tfID); 2138 ctx.expectError (GL_NO_ERROR); 2139 } 2140 2141 void end_transform_feedback (NegativeTestContext& ctx) 2142 { 2143 GLuint tfID = 0; 2144 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2145 deUint32 buf = 0x1234; 2146 const char* tfVarying = "gl_Position"; 2147 2148 ctx.glGenBuffers (1, &buf); 2149 ctx.glGenTransformFeedbacks (1, &tfID); 2150 2151 ctx.glUseProgram (program.getProgram()); 2152 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2153 ctx.glLinkProgram (program.getProgram()); 2154 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID); 2155 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf); 2156 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 2157 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 2158 ctx.expectError (GL_NO_ERROR); 2159 2160 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is not active."); 2161 ctx.glEndTransformFeedback (); 2162 ctx.expectError (GL_INVALID_OPERATION); 2163 ctx.glBeginTransformFeedback (GL_TRIANGLES); 2164 ctx.glEndTransformFeedback (); 2165 ctx.expectError (GL_NO_ERROR); 2166 ctx.endSection(); 2167 2168 ctx.glDeleteBuffers (1, &buf); 2169 ctx.glDeleteTransformFeedbacks (1, &tfID); 2170 ctx.expectError (GL_NO_ERROR); 2171 } 2172 2173 void get_transform_feedback_varying (NegativeTestContext& ctx) 2174 { 2175 GLuint tfID = 0; 2176 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2177 glu::ShaderProgram programInvalid (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, "")); 2178 const char* tfVarying = "gl_Position"; 2179 int maxTransformFeedbackVaryings = 0; 2180 2181 GLsizei length; 2182 GLsizei size; 2183 GLenum type; 2184 char name[32]; 2185 2186 const GLuint notAProgram = ctx.glCreateProgram(); 2187 ctx.glDeleteProgram(notAProgram); 2188 2189 ctx.glGenTransformFeedbacks (1, &tfID); 2190 2191 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2192 ctx.expectError (GL_NO_ERROR); 2193 ctx.glLinkProgram (program.getProgram()); 2194 ctx.expectError (GL_NO_ERROR); 2195 2196 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID); 2197 ctx.expectError (GL_NO_ERROR); 2198 2199 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object."); 2200 ctx.glGetTransformFeedbackVarying (notAProgram, 0, 32, &length, &size, &type, &name[0]); 2201 ctx.expectError (GL_INVALID_VALUE); 2202 ctx.endSection(); 2203 2204 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater or equal to the value of GL_TRANSFORM_FEEDBACK_VARYINGS."); 2205 ctx.glGetProgramiv (program.getProgram(), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxTransformFeedbackVaryings); 2206 ctx.glGetTransformFeedbackVarying (program.getProgram(), maxTransformFeedbackVaryings, 32, &length, &size, &type, &name[0]); 2207 ctx.expectError (GL_INVALID_VALUE); 2208 ctx.endSection(); 2209 2210 ctx.beginSection("GL_INVALID_OPERATION or GL_INVALID_VALUE is generated program has not been linked."); 2211 ctx.glGetTransformFeedbackVarying (programInvalid.getProgram(), 0, 32, &length, &size, &type, &name[0]); 2212 ctx.expectError (GL_INVALID_OPERATION, GL_INVALID_VALUE); 2213 ctx.endSection(); 2214 2215 ctx.glDeleteTransformFeedbacks (1, &tfID); 2216 ctx.expectError (GL_NO_ERROR); 2217 } 2218 2219 void transform_feedback_varyings (NegativeTestContext& ctx) 2220 { 2221 GLuint tfID = 0; 2222 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER); 2223 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); 2224 const char* tfVarying = "gl_Position"; 2225 GLint maxTransformFeedbackSeparateAttribs = 0; 2226 2227 const GLuint notAProgram = ctx.glCreateProgram(); 2228 ctx.glDeleteProgram(notAProgram); 2229 2230 ctx.glGenTransformFeedbacks (1, &tfID); 2231 ctx.expectError (GL_NO_ERROR); 2232 2233 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object."); 2234 ctx.glTransformFeedbackVaryings (notAProgram, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2235 ctx.expectError (GL_INVALID_VALUE); 2236 ctx.endSection(); 2237 2238 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object."); 2239 ctx.glTransformFeedbackVaryings(shader, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2240 ctx.expectError(GL_INVALID_OPERATION); 2241 ctx.glDeleteShader(shader); 2242 ctx.endSection(); 2243 2244 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 2245 ctx.glTransformFeedbackVaryings(program.getProgram(), -1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 2246 ctx.expectError(GL_INVALID_VALUE); 2247 ctx.endSection(); 2248 2249 ctx.beginSection("GL_INVALID_ENUM is generated if bufferMode is not SEPARATE_ATTRIBS or INTERLEAVED_ATTRIBS."); 2250 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, 0); 2251 ctx.expectError(GL_INVALID_ENUM); 2252 ctx.endSection(); 2253 2254 ctx.beginSection("GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."); 2255 ctx.glGetIntegerv (GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs); 2256 ctx.glTransformFeedbackVaryings (program.getProgram(), maxTransformFeedbackSeparateAttribs+1, &tfVarying, GL_SEPARATE_ATTRIBS); 2257 ctx.expectError (GL_INVALID_VALUE); 2258 ctx.endSection(); 2259 2260 ctx.glDeleteTransformFeedbacks (1, &tfID); 2261 ctx.expectError (GL_NO_ERROR); 2262 2263 } 2264 2265 void link_compute_shader (NegativeTestContext& ctx) 2266 { 2267 const char* computeShaderSource = "#version 320 es\n" 2268 "void main (void)\n" 2269 "{\n" 2270 "}\n\0"; 2271 { 2272 const GLenum shaderTypes[] = { 2273 GL_VERTEX_SHADER, 2274 GL_FRAGMENT_SHADER, 2275 GL_GEOMETRY_SHADER, 2276 GL_TESS_CONTROL_SHADER, 2277 GL_TESS_EVALUATION_SHADER 2278 }; 2279 2280 ctx.beginSection("Compute Shader linked with shader of other kind."); 2281 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ndx++) 2282 { 2283 GLint linkStatus = -1; 2284 GLuint program = ctx.glCreateProgram(); 2285 GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER); 2286 GLuint otherShader = ctx.glCreateShader(shaderTypes[ndx]); 2287 const char* otherShaderSource = (shaderTypes[ndx] != GL_GEOMETRY_SHADER) ? 2288 computeShaderSource : 2289 "#version 320 es\n" 2290 "layout(max_vertices = 3) out;\n" 2291 "void main(void){}\n\0"; 2292 2293 ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL); 2294 ctx.glShaderSource(otherShader, 1, &otherShaderSource, DE_NULL); 2295 ctx.glCompileShader(computeShader); 2296 ctx.glCompileShader(otherShader); 2297 ctx.glAttachShader(program, computeShader); 2298 ctx.glAttachShader(program, otherShader); 2299 ctx.glLinkProgram(program); 2300 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); 2301 ctx.glDeleteShader(otherShader); 2302 ctx.glDeleteShader(computeShader); 2303 ctx.glDeleteProgram(program); 2304 if (linkStatus != GL_FALSE) 2305 ctx.fail("Program should not have linked"); 2306 } 2307 ctx.endSection(); 2308 } 2309 { 2310 const char* computeShaderSource310 = "#version 310 es\n" 2311 "void main (void)\n" 2312 "{\n" 2313 "}\n\0"; 2314 GLint linkStatus = -1; 2315 GLuint program = ctx.glCreateProgram(); 2316 GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER); 2317 GLuint computeShader310 = ctx.glCreateShader(GL_FRAGMENT_SHADER); 2318 2319 ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL); 2320 ctx.glShaderSource(computeShader310, 1, &computeShaderSource310, DE_NULL); 2321 ctx.beginSection("Compute Shader should not be linked with shaders of different version."); 2322 ctx.glCompileShader(computeShader); 2323 ctx.glCompileShader(computeShader310); 2324 ctx.glAttachShader(program, computeShader); 2325 ctx.glAttachShader(program, computeShader310); 2326 ctx.glLinkProgram(program); 2327 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); 2328 ctx.glDeleteShader(computeShader310); 2329 ctx.glDeleteShader(computeShader); 2330 ctx.glDeleteProgram(program); 2331 if (linkStatus != GL_FALSE) 2332 ctx.fail("Program should not have linked"); 2333 ctx.endSection(); 2334 } 2335 } 2336 2337 void compile_compute_shader_helper (NegativeTestContext& ctx, const char** computeShaderSource, GLint* compileStatus) 2338 { 2339 GLuint shader = ctx.glCreateShader(GL_COMPUTE_SHADER); 2340 2341 *compileStatus = -1; 2342 ctx.glShaderSource(shader, 1, computeShaderSource, DE_NULL); 2343 ctx.glCompileShader(shader); 2344 ctx.glGetShaderiv(shader, GL_COMPILE_STATUS, compileStatus); 2345 ctx.glDeleteShader(shader); 2346 } 2347 2348 void compile_compute_shader (NegativeTestContext& ctx) 2349 { 2350 GLint compileStatus; 2351 ctx.beginSection("Compile Computer Shader"); 2352 2353 { 2354 const char* computeShaderSource = "#version 300 es\n" 2355 "void main (void)\n" 2356 "{\n" 2357 "}\n\0"; 2358 2359 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2360 if (compileStatus != GL_FALSE) 2361 ctx.fail("Compute Shader should not have compiled with #version 300 es."); 2362 } 2363 { 2364 const char* computeShaderSource = "#version 310 es\n" 2365 "buffer SSBO { vec4 data }" 2366 "void main (void)\n" 2367 "{\n" 2368 "}\n\0"; 2369 2370 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2371 if (compileStatus != GL_FALSE) 2372 ctx.fail("Compute Shader should not have compiled: incorrect SSBO syntax."); 2373 } 2374 { 2375 const char* computeShaderSource = "#version 310 es\n" 2376 "buffer SSBO { vec4 data;};" 2377 "uniform mat4 data;" 2378 "void main (void)\n" 2379 "{\n" 2380 "}\n\0"; 2381 2382 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2383 if (compileStatus != GL_FALSE) 2384 ctx.fail("Compute Shader should not have compiled: buffer variable redefinition."); 2385 } 2386 { 2387 const char* computeShaderSource = "#version 310 es\n" 2388 "buffer SSBO { vec4 data[]; vec4 moreData;};" 2389 "void main (void)\n" 2390 "{\n" 2391 "}\n\0"; 2392 2393 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2394 if (compileStatus != GL_FALSE) 2395 ctx.fail("Compute Shader should not have compiled: unspecified length buffer member not at the end."); 2396 } 2397 { 2398 const char* computeShaderSource = "#version 310 es\n" 2399 "in vec4 data;" 2400 "void main (void)\n" 2401 "{\n" 2402 "}\n\0"; 2403 2404 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2405 if (compileStatus != GL_FALSE) 2406 ctx.fail("Compute Shader should not have compiled: input qualifier used."); 2407 } 2408 { 2409 const char* computeShaderSource = "#version 310 es\n" 2410 "shared uint data = 0;"; 2411 2412 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus); 2413 if (compileStatus != GL_FALSE) 2414 ctx.fail("Compute Shader should not have compiled: shared-qualified variable initialized."); 2415 } 2416 ctx.endSection(); 2417 } 2418 2419 std::vector<FunctionContainer> getNegativeShaderApiTestFunctions () 2420 { 2421 FunctionContainer funcs[] = 2422 { 2423 {create_shader, "create_shader", "Invalid glCreateShader() usage" }, 2424 {shader_source, "shader_source", "Invalid glShaderSource() usage" }, 2425 {compile_shader, "compile_shader", "Invalid glCompileShader() usage" }, 2426 {delete_shader, "delete_shader", "Invalid glDeleteShader() usage" }, 2427 {shader_binary, "shader_binary", "Invalid glShaderBinary() usage" }, 2428 {attach_shader, "attach_shader", "Invalid glAttachShader() usage" }, 2429 {detach_shader, "detach_shader", "Invalid glDetachShader() usage" }, 2430 {link_program, "link_program", "Invalid glLinkProgram() usage" }, 2431 {use_program, "use_program", "Invalid glUseProgram() usage" }, 2432 {delete_program, "delete_program", "Invalid glDeleteProgram() usage" }, 2433 {validate_program, "validate_program", "Invalid glValidateProgram() usage" }, 2434 {get_program_binary, "get_program_binary", "Invalid glGetProgramBinary() usage" }, 2435 {program_binary, "program_binary", "Invalid glProgramBinary() usage" }, 2436 {program_parameteri, "program_parameteri", "Invalid glProgramParameteri() usage" }, 2437 {gen_samplers, "gen_samplers", "Invalid glGenSamplers() usage" }, 2438 {bind_sampler, "bind_sampler", "Invalid glBindSampler() usage" }, 2439 {delete_samplers, "delete_samplers", "Invalid glDeleteSamplers() usage" }, 2440 {get_sampler_parameteriv, "get_sampler_parameteriv", "Invalid glGetSamplerParameteriv() usage" }, 2441 {get_sampler_parameterfv, "get_sampler_parameterfv", "Invalid glGetSamplerParameterfv() usage" }, 2442 {get_sampler_parameterIiv, "get_sampler_parameterIiv", "Invalid glGetSamplerParameterIiv() usage" }, 2443 {get_sampler_parameterIuiv, "get_sampler_parameterIuiv", "Invalid glGetSamplerParameterIuiv() usage" }, 2444 {sampler_parameteri, "sampler_parameteri", "Invalid glSamplerParameteri() usage" }, 2445 {sampler_parameteriv, "sampler_parameteriv", "Invalid glSamplerParameteriv() usage" }, 2446 {sampler_parameterf, "sampler_parameterf", "Invalid glSamplerParameterf() usage" }, 2447 {sampler_parameterfv, "sampler_parameterfv", "Invalid glSamplerParameterfv() usage" }, 2448 {sampler_parameterIiv, "sampler_parameterIiv", "Invalid glSamplerParameterIiv() usage" }, 2449 {sampler_parameterIuiv, "sampler_parameterIuiv", "Invalid glSamplerParameterIuiv() usage" }, 2450 {get_attrib_location, "get_attrib_location", "Invalid glGetAttribLocation() usage" }, 2451 {get_uniform_location, "get_uniform_location", "Invalid glGetUniformLocation() usage" }, 2452 {bind_attrib_location, "bind_attrib_location", "Invalid glBindAttribLocation() usage" }, 2453 {uniform_block_binding, "uniform_block_binding", "Invalid glUniformBlockBinding() usage" }, 2454 {uniformf_invalid_program, "uniformf_invalid_program", "Invalid glUniform{1234}f() usage" }, 2455 {uniformf_incompatible_type, "uniformf_incompatible_type", "Invalid glUniform{1234}f() usage" }, 2456 {uniformf_invalid_location, "uniformf_invalid_location", "Invalid glUniform{1234}f() usage" }, 2457 {uniformfv_invalid_program, "uniformfv_invalid_program", "Invalid glUniform{1234}fv() usage" }, 2458 {uniformfv_incompatible_type, "uniformfv_incompatible_type", "Invalid glUniform{1234}fv() usage" }, 2459 {uniformfv_invalid_location, "uniformfv_invalid_location", "Invalid glUniform{1234}fv() usage" }, 2460 {uniformfv_invalid_count, "uniformfv_invalid_count", "Invalid glUniform{1234}fv() usage" }, 2461 {uniformi_invalid_program, "uniformi_invalid_program", "Invalid glUniform{1234}i() usage" }, 2462 {uniformi_incompatible_type, "uniformi_incompatible_type", "Invalid glUniform{1234}i() usage" }, 2463 {uniformi_invalid_location, "uniformi_invalid_location", "Invalid glUniform{1234}i() usage" }, 2464 {uniformiv_invalid_program, "uniformiv_invalid_program", "Invalid glUniform{1234}iv() usage" }, 2465 {uniformiv_incompatible_type, "uniformiv_incompatible_type", "Invalid glUniform{1234}iv() usage" }, 2466 {uniformiv_invalid_location, "uniformiv_invalid_location", "Invalid glUniform{1234}iv() usage" }, 2467 {uniformiv_invalid_count, "uniformiv_invalid_count", "Invalid glUniform{1234}iv() usage" }, 2468 {uniformui_invalid_program, "uniformui_invalid_program", "Invalid glUniform{234}ui() usage" }, 2469 {uniformui_incompatible_type, "uniformui_incompatible_type", "Invalid glUniform{1234}ui() usage" }, 2470 {uniformui_invalid_location, "uniformui_invalid_location", "Invalid glUniform{1234}ui() usage" }, 2471 {uniformuiv_invalid_program, "uniformuiv_invalid_program", "Invalid glUniform{234}uiv() usage" }, 2472 {uniformuiv_incompatible_type, "uniformuiv_incompatible_type", "Invalid glUniform{1234}uiv() usage" }, 2473 {uniformuiv_invalid_location, "uniformuiv_invalid_location", "Invalid glUniform{1234}uiv() usage" }, 2474 {uniformuiv_invalid_count, "uniformuiv_invalid_count", "Invalid glUniform{1234}uiv() usage" }, 2475 {uniform_matrixfv_invalid_program, "uniform_matrixfv_invalid_program", "Invalid glUniformMatrix{234}fv() usage" }, 2476 {uniform_matrixfv_incompatible_type, "uniform_matrixfv_incompatible_type", "Invalid glUniformMatrix{234}fv() usage" }, 2477 {uniform_matrixfv_invalid_location, "uniform_matrixfv_invalid_location", "Invalid glUniformMatrix{234}fv() usage" }, 2478 {uniform_matrixfv_invalid_count, "uniform_matrixfv_invalid_count", "Invalid glUniformMatrix{234}fv() usage" }, 2479 {gen_transform_feedbacks, "gen_transform_feedbacks", "Invalid glGenTransformFeedbacks() usage" }, 2480 {bind_transform_feedback, "bind_transform_feedback", "Invalid glBindTransformFeedback() usage" }, 2481 {delete_transform_feedbacks, "delete_transform_feedbacks", "Invalid glDeleteTransformFeedbacks() usage" }, 2482 {begin_transform_feedback, "begin_transform_feedback", "Invalid glBeginTransformFeedback() usage" }, 2483 {pause_transform_feedback, "pause_transform_feedback", "Invalid glPauseTransformFeedback() usage" }, 2484 {resume_transform_feedback, "resume_transform_feedback", "Invalid glResumeTransformFeedback() usage" }, 2485 {end_transform_feedback, "end_transform_feedback", "Invalid glEndTransformFeedback() usage" }, 2486 {get_transform_feedback_varying, "get_transform_feedback_varying", "Invalid glGetTransformFeedbackVarying() usage"}, 2487 {transform_feedback_varyings, "transform_feedback_varyings", "Invalid glTransformFeedbackVaryings() usage" }, 2488 {compile_compute_shader, "compile_compute_shader", "Invalid Compute Shader compilation" }, 2489 {link_compute_shader, "link_compute_shader", "Invalid Compute Shader linkage" }, 2490 }; 2491 2492 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 2493 } 2494 2495 } // NegativeTestShared 2496 } // Functional 2497 } // gles31 2498 } // deqp 2499
