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 Vertex Array API tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fNegativeVertexArrayApiTests.hpp" 25 #include "gluCallLogWrapper.hpp" 26 #include "gluContextInfo.hpp" 27 #include "gluShaderProgram.hpp" 28 #include "glwDefs.hpp" 29 #include "glwEnums.hpp" 30 #include "tcuStringTemplate.hpp" 31 32 namespace deqp 33 { 34 35 using std::string; 36 using std::map; 37 38 namespace gles31 39 { 40 namespace Functional 41 { 42 namespace NegativeTestShared 43 { 44 45 using tcu::TestLog; 46 using glu::CallLogWrapper; 47 using namespace glw; 48 49 static const char* vertexShaderSource = "${GLSL_VERSION_STRING}\n" 50 "void main (void)\n" 51 "{\n" 52 " gl_Position = vec4(0.0);\n" 53 "}\n\0"; 54 55 static const char* fragmentShaderSource = "${GLSL_VERSION_STRING}\n" 56 "layout(location = 0) out mediump vec4 fragColor;" 57 "void main (void)\n" 58 "{\n" 59 " fragColor = vec4(0.0);\n" 60 "}\n\0"; 61 62 void vertex_attribf (NegativeTestContext& ctx) 63 { 64 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 65 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 66 ctx.glVertexAttrib1f(maxVertexAttribs, 0.0f); 67 ctx.expectError(GL_INVALID_VALUE); 68 ctx.glVertexAttrib2f(maxVertexAttribs, 0.0f, 0.0f); 69 ctx.expectError(GL_INVALID_VALUE); 70 ctx.glVertexAttrib3f(maxVertexAttribs, 0.0f, 0.0f, 0.0f); 71 ctx.expectError(GL_INVALID_VALUE); 72 ctx.glVertexAttrib4f(maxVertexAttribs, 0.0f, 0.0f, 0.0f, 0.0f); 73 ctx.expectError(GL_INVALID_VALUE); 74 ctx.endSection(); 75 } 76 77 void vertex_attribfv (NegativeTestContext& ctx) 78 { 79 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 80 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 81 float v[4] = {0.0f}; 82 ctx.glVertexAttrib1fv(maxVertexAttribs, &v[0]); 83 ctx.expectError(GL_INVALID_VALUE); 84 ctx.glVertexAttrib2fv(maxVertexAttribs, &v[0]); 85 ctx.expectError(GL_INVALID_VALUE); 86 ctx.glVertexAttrib3fv(maxVertexAttribs, &v[0]); 87 ctx.expectError(GL_INVALID_VALUE); 88 ctx.glVertexAttrib4fv(maxVertexAttribs, &v[0]); 89 ctx.expectError(GL_INVALID_VALUE); 90 ctx.endSection(); 91 } 92 93 void vertex_attribi4 (NegativeTestContext& ctx) 94 { 95 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 96 GLint valInt = 0; 97 GLuint valUint = 0; 98 99 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 100 ctx.glVertexAttribI4i(maxVertexAttribs, valInt, valInt, valInt, valInt); 101 ctx.expectError(GL_INVALID_VALUE); 102 ctx.glVertexAttribI4ui(maxVertexAttribs, valUint, valUint, valUint, valUint); 103 ctx.expectError(GL_INVALID_VALUE); 104 ctx.endSection(); 105 } 106 107 void vertex_attribi4v (NegativeTestContext& ctx) 108 { 109 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 110 GLint valInt[4] = { 0 }; 111 GLuint valUint[4] = { 0 }; 112 113 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 114 ctx.glVertexAttribI4iv(maxVertexAttribs, &valInt[0]); 115 ctx.expectError(GL_INVALID_VALUE); 116 ctx.glVertexAttribI4uiv(maxVertexAttribs, &valUint[0]); 117 ctx.expectError(GL_INVALID_VALUE); 118 ctx.endSection(); 119 } 120 121 void vertex_attrib_pointer (NegativeTestContext& ctx) 122 { 123 ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value."); 124 ctx.glVertexAttribPointer(0, 1, 0, GL_TRUE, 0, 0); 125 ctx.expectError(GL_INVALID_ENUM); 126 ctx.endSection(); 127 128 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 129 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 130 ctx.glVertexAttribPointer(maxVertexAttribs, 1, GL_BYTE, GL_TRUE, 0, 0); 131 ctx.expectError(GL_INVALID_VALUE); 132 ctx.endSection(); 133 134 ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4."); 135 ctx.glVertexAttribPointer(0, 0, GL_BYTE, GL_TRUE, 0, 0); 136 ctx.expectError(GL_INVALID_VALUE); 137 ctx.endSection(); 138 139 ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative."); 140 ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, -1, 0); 141 ctx.expectError(GL_INVALID_VALUE); 142 ctx.endSection(); 143 144 ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV or GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4."); 145 ctx.glVertexAttribPointer(0, 2, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0); 146 ctx.expectError(GL_INVALID_OPERATION); 147 ctx.glVertexAttribPointer(0, 2, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0); 148 ctx.expectError(GL_INVALID_OPERATION); 149 ctx.glVertexAttribPointer(0, 4, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0); 150 ctx.expectError(GL_NO_ERROR); 151 ctx.glVertexAttribPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0); 152 ctx.expectError(GL_NO_ERROR); 153 ctx.endSection(); 154 155 ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL."); 156 GLuint vao = 0; 157 GLbyte offset = 1; 158 ctx.glGenVertexArrays(1, &vao); 159 ctx.glBindVertexArray(vao); 160 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 161 ctx.expectError(GL_NO_ERROR); 162 163 ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, 0, &offset); 164 ctx.expectError(GL_INVALID_OPERATION); 165 166 ctx.glBindVertexArray(0); 167 ctx.glDeleteVertexArrays(1, &vao); 168 ctx.expectError(GL_NO_ERROR); 169 ctx.endSection(); 170 } 171 172 void vertex_attrib_i_pointer (NegativeTestContext& ctx) 173 { 174 ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value."); 175 ctx.glVertexAttribIPointer(0, 1, 0, 0, 0); 176 ctx.expectError(GL_INVALID_ENUM); 177 ctx.glVertexAttribIPointer(0, 4, GL_INT_2_10_10_10_REV, 0, 0); 178 ctx.expectError(GL_INVALID_ENUM); 179 ctx.glVertexAttribIPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, 0); 180 ctx.expectError(GL_INVALID_ENUM); 181 ctx.endSection(); 182 183 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 184 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 185 ctx.glVertexAttribIPointer(maxVertexAttribs, 1, GL_BYTE, 0, 0); 186 ctx.expectError(GL_INVALID_VALUE); 187 ctx.endSection(); 188 189 ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4."); 190 ctx.glVertexAttribIPointer(0, 0, GL_BYTE, 0, 0); 191 ctx.expectError(GL_INVALID_VALUE); 192 ctx.endSection(); 193 194 ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative."); 195 ctx.glVertexAttribIPointer(0, 1, GL_BYTE, -1, 0); 196 ctx.expectError(GL_INVALID_VALUE); 197 ctx.endSection(); 198 199 ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL."); 200 GLuint vao = 0; 201 GLbyte offset = 1; 202 ctx.glGenVertexArrays(1, &vao); 203 ctx.glBindVertexArray(vao); 204 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 205 ctx.expectError(GL_NO_ERROR); 206 207 ctx.glVertexAttribIPointer(0, 1, GL_BYTE, 0, &offset); 208 ctx.expectError(GL_INVALID_OPERATION); 209 210 ctx.glBindVertexArray(0); 211 ctx.glDeleteVertexArrays(1, &vao); 212 ctx.expectError(GL_NO_ERROR); 213 ctx.endSection(); 214 } 215 216 void vertex_attrib_format (NegativeTestContext& ctx) 217 { 218 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 219 int maxVertexAttribRelativeOffset = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET); 220 GLuint vao = 0; 221 222 ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of MAX_VERTEX_ATTRIBS."); 223 ctx.glGenVertexArrays(1, &vao); 224 ctx.glBindVertexArray(vao); 225 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 226 ctx.glVertexAttribFormat(maxVertexAttribs, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset); 227 ctx.expectError(GL_INVALID_VALUE); 228 ctx.endSection(); 229 230 ctx.beginSection("GL_INVALID_VALUE is generated if size is not one of 1, 2, 3, 4."); 231 ctx.glGenVertexArrays(1, &vao); 232 ctx.glBindVertexArray(vao); 233 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 234 ctx.glVertexAttribFormat(1, 0, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset); 235 ctx.expectError(GL_INVALID_VALUE); 236 ctx.endSection(); 237 238 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed."); 239 ctx.glGenVertexArrays(1, &vao); 240 ctx.glBindVertexArray(vao); 241 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 242 ctx.glVertexAttribFormat(1, 4, 1, GL_FALSE, 0); 243 ctx.expectError(GL_INVALID_ENUM); 244 ctx.endSection(); 245 246 ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed."); 247 ctx.glGenVertexArrays(1, &vao); 248 ctx.glBindVertexArray(0); 249 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 250 ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, 0); 251 ctx.expectError(GL_INVALID_OPERATION); 252 ctx.endSection(); 253 254 ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV and size is not 4."); 255 ctx.glGenVertexArrays(1, &vao); 256 ctx.glBindVertexArray(vao); 257 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 258 ctx.glVertexAttribFormat(1, 3, GL_INT_2_10_10_10_REV, GL_FALSE, 0); 259 ctx.expectError(GL_INVALID_OPERATION); 260 ctx.endSection(); 261 262 ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4."); 263 ctx.glGenVertexArrays(1, &vao); 264 ctx.glBindVertexArray(vao); 265 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 266 ctx.glVertexAttribFormat(1, 3, GL_UNSIGNED_INT_2_10_10_10_REV, GL_FALSE, 0); 267 ctx.expectError(GL_INVALID_OPERATION); 268 ctx.endSection(); 269 270 ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET."); 271 ctx.glGenVertexArrays(1, &vao); 272 ctx.glBindVertexArray(vao); 273 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 274 ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset + 1); 275 ctx.expectError(GL_INVALID_VALUE); 276 ctx.endSection(); 277 } 278 279 void vertex_attrib_i_format (NegativeTestContext& ctx) 280 { 281 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 282 int maxVertexAttribRelativeOffset = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET); 283 GLuint vao = 0; 284 285 ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of GL_MAX_VERTEX_ATTRIBS."); 286 ctx.glGenVertexArrays(1, &vao); 287 ctx.glBindVertexArray(vao); 288 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 289 ctx.glVertexAttribIFormat(maxVertexAttribs, 4, GL_INT, 0); 290 ctx.expectError(GL_INVALID_VALUE); 291 ctx.endSection(); 292 293 ctx.beginSection("GL_INVALID_VALUE is generated if size is not one the values 1, 2, 3, 4."); 294 ctx.glGenVertexArrays(1, &vao); 295 ctx.glBindVertexArray(vao); 296 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 297 ctx.glVertexAttribIFormat(1, 0, GL_INT, 0); 298 ctx.expectError(GL_INVALID_VALUE); 299 ctx.endSection(); 300 301 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed."); 302 ctx.glGenVertexArrays(1, &vao); 303 ctx.glBindVertexArray(vao); 304 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 305 ctx.glVertexAttribIFormat(1, 4, GL_FLOAT, 0); 306 ctx.expectError(GL_INVALID_ENUM); 307 ctx.endSection(); 308 309 ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed."); 310 ctx.glGenVertexArrays(1, &vao); 311 ctx.glBindVertexArray(0); 312 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 313 ctx.glVertexAttribIFormat(1, 4, GL_INT, 0); 314 ctx.expectError(GL_INVALID_OPERATION); 315 ctx.endSection(); 316 317 ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET."); 318 ctx.glGenVertexArrays(1, &vao); 319 ctx.glBindVertexArray(vao); 320 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 321 ctx.glVertexAttribIFormat(1, 4, GL_INT, maxVertexAttribRelativeOffset + 1); 322 ctx.expectError(GL_INVALID_VALUE); 323 ctx.endSection(); 324 } 325 326 void enable_vertex_attrib_array (NegativeTestContext& ctx) 327 { 328 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 329 330 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 331 ctx.glEnableVertexAttribArray(maxVertexAttribs); 332 ctx.expectError(GL_INVALID_VALUE); 333 ctx.endSection(); 334 } 335 336 void disable_vertex_attrib_array (NegativeTestContext& ctx) 337 { 338 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 339 340 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 341 ctx.glDisableVertexAttribArray(maxVertexAttribs); 342 ctx.expectError(GL_INVALID_VALUE); 343 ctx.endSection(); 344 } 345 346 void gen_vertex_arrays (NegativeTestContext& ctx) 347 { 348 GLuint arrays = 0; 349 350 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 351 ctx.glGenVertexArrays(-1, &arrays); 352 ctx.expectError(GL_INVALID_VALUE); 353 ctx.endSection(); 354 } 355 356 void bind_vertex_array (NegativeTestContext& ctx) 357 { 358 ctx.beginSection("GL_INVALID_OPERATION is generated if array is not zero or the name of an existing vertex array object."); 359 ctx.glBindVertexArray(-1); 360 ctx.expectError(GL_INVALID_OPERATION); 361 ctx.endSection(); 362 } 363 364 void delete_vertex_arrays (NegativeTestContext& ctx) 365 { 366 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 367 ctx.glDeleteVertexArrays(-1, 0); 368 ctx.expectError(GL_INVALID_VALUE); 369 ctx.endSection(); 370 } 371 372 void vertex_attrib_divisor (NegativeTestContext& ctx) 373 { 374 int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS); 375 376 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS."); 377 ctx.glVertexAttribDivisor(maxVertexAttribs, 0); 378 ctx.expectError(GL_INVALID_VALUE); 379 ctx.endSection(); 380 } 381 382 void draw_arrays (NegativeTestContext& ctx) 383 { 384 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 385 GLuint fbo = 0; 386 map<string, string> args; 387 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 388 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 389 390 ctx.glUseProgram(program.getProgram()); 391 ctx.expectError(GL_NO_ERROR); 392 393 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 394 ctx.glDrawArrays(-1, 0, 1); 395 ctx.expectError(GL_INVALID_ENUM); 396 ctx.endSection(); 397 398 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 399 ctx.glDrawArrays(GL_POINTS, 0, -1); 400 ctx.expectError(GL_INVALID_VALUE); 401 ctx.endSection(); 402 403 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 404 ctx.glGenFramebuffers(1, &fbo); 405 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 406 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 407 ctx.glDrawArrays(GL_POINTS, 0, 1); 408 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 409 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 410 ctx.glDeleteFramebuffers(1, &fbo); 411 ctx.endSection(); 412 413 ctx.glUseProgram(0); 414 } 415 416 void draw_arrays_invalid_program (NegativeTestContext& ctx) 417 { 418 GLuint fbo = 0; 419 ctx.glUseProgram(0); 420 421 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 422 ctx.glDrawArrays(-1, 0, 1); 423 ctx.expectError(GL_INVALID_ENUM); 424 ctx.endSection(); 425 426 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 427 ctx.glDrawArrays(GL_POINTS, 0, -1); 428 ctx.expectError(GL_INVALID_VALUE); 429 ctx.endSection(); 430 431 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 432 ctx.glGenFramebuffers(1, &fbo); 433 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 434 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 435 ctx.glDrawArrays(GL_POINTS, 0, 1); 436 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 437 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 438 ctx.glDeleteFramebuffers(1, &fbo); 439 ctx.endSection(); 440 } 441 442 void draw_arrays_incomplete_primitive (NegativeTestContext& ctx) 443 { 444 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 445 GLuint fbo = 0; 446 map<string, string> args; 447 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 448 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 449 450 ctx.glUseProgram(program.getProgram()); 451 ctx.expectError(GL_NO_ERROR); 452 453 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 454 ctx.glDrawArrays(-1, 0, 1); 455 ctx.expectError(GL_INVALID_ENUM); 456 ctx.endSection(); 457 458 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 459 ctx.glDrawArrays(GL_TRIANGLES, 0, -1); 460 ctx.expectError(GL_INVALID_VALUE); 461 ctx.endSection(); 462 463 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 464 ctx.glGenFramebuffers(1, &fbo); 465 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 466 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 467 ctx.glDrawArrays(GL_TRIANGLES, 0, 1); 468 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 469 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 470 ctx.glDeleteFramebuffers(1, &fbo); 471 ctx.endSection(); 472 473 ctx.glUseProgram(0); 474 } 475 476 void draw_elements (NegativeTestContext& ctx) 477 { 478 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 479 GLuint fbo = 0; 480 GLuint buf = 0; 481 GLuint tfID = 0; 482 GLfloat vertices[1]; 483 map<string, string> args; 484 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 485 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 486 487 ctx.glUseProgram(program.getProgram()); 488 ctx.expectError(GL_NO_ERROR); 489 490 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 491 ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices); 492 ctx.expectError(GL_INVALID_ENUM); 493 ctx.endSection(); 494 495 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 496 ctx.glDrawElements(GL_POINTS, 1, -1, vertices); 497 ctx.expectError(GL_INVALID_ENUM); 498 ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, vertices); 499 ctx.expectError(GL_INVALID_ENUM); 500 ctx.endSection(); 501 502 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 503 ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices); 504 ctx.expectError(GL_INVALID_VALUE); 505 ctx.endSection(); 506 507 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 508 ctx.glGenFramebuffers(1, &fbo); 509 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 510 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 511 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices); 512 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 513 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 514 ctx.glDeleteFramebuffers(1, &fbo); 515 ctx.endSection(); 516 517 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 518 { 519 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 520 const char* tfVarying = "gl_Position"; 521 522 ctx.glGenBuffers(1, &buf); 523 ctx.glGenTransformFeedbacks(1, &tfID); 524 525 ctx.glUseProgram(program.getProgram()); 526 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 527 ctx.glLinkProgram(program.getProgram()); 528 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 529 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 530 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 531 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 532 ctx.glBeginTransformFeedback(GL_POINTS); 533 ctx.expectError(GL_NO_ERROR); 534 535 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices); 536 ctx.expectError(GL_INVALID_OPERATION); 537 538 ctx.glPauseTransformFeedback(); 539 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices); 540 ctx.expectError(GL_NO_ERROR); 541 542 ctx.glEndTransformFeedback(); 543 ctx.glDeleteBuffers(1, &buf); 544 ctx.glDeleteTransformFeedbacks(1, &tfID); 545 ctx.expectError(GL_NO_ERROR); 546 ctx.endSection(); 547 } 548 549 ctx.glUseProgram(0); 550 } 551 552 void draw_elements_invalid_program (NegativeTestContext& ctx) 553 { 554 ctx.glUseProgram(0); 555 GLuint fbo = 0; 556 GLfloat vertices[1]; 557 558 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 559 ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices); 560 ctx.expectError(GL_INVALID_ENUM); 561 ctx.endSection(); 562 563 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 564 ctx.glDrawElements(GL_POINTS, 1, -1, vertices); 565 ctx.expectError(GL_INVALID_ENUM); 566 ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, vertices); 567 ctx.expectError(GL_INVALID_ENUM); 568 ctx.endSection(); 569 570 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 571 ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices); 572 ctx.expectError(GL_INVALID_VALUE); 573 ctx.endSection(); 574 575 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 576 ctx.glGenFramebuffers(1, &fbo); 577 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 578 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 579 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices); 580 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 581 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 582 ctx.glDeleteFramebuffers(1, &fbo); 583 ctx.endSection(); 584 } 585 586 void draw_elements_incomplete_primitive (NegativeTestContext& ctx) 587 { 588 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 589 GLuint fbo = 0; 590 GLuint buf = 0; 591 GLuint tfID = 0; 592 GLfloat vertices[1]; 593 map<string, string> args; 594 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 595 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 596 597 ctx.glUseProgram(program.getProgram()); 598 ctx.expectError(GL_NO_ERROR); 599 600 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 601 ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices); 602 ctx.expectError(GL_INVALID_ENUM); 603 ctx.endSection(); 604 605 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 606 ctx.glDrawElements(GL_TRIANGLES, 1, -1, vertices); 607 ctx.expectError(GL_INVALID_ENUM); 608 ctx.glDrawElements(GL_TRIANGLES, 1, GL_FLOAT, vertices); 609 ctx.expectError(GL_INVALID_ENUM); 610 ctx.endSection(); 611 612 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 613 ctx.glDrawElements(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, vertices); 614 ctx.expectError(GL_INVALID_VALUE); 615 ctx.endSection(); 616 617 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 618 ctx.glGenFramebuffers(1, &fbo); 619 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 620 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 621 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices); 622 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 623 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 624 ctx.glDeleteFramebuffers(1, &fbo); 625 ctx.endSection(); 626 627 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 628 { 629 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 630 const char* tfVarying= "gl_Position"; 631 632 ctx.glGenBuffers(1, &buf); 633 ctx.glGenTransformFeedbacks(1, &tfID); 634 635 ctx.glUseProgram(program.getProgram()); 636 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 637 ctx.glLinkProgram(program.getProgram()); 638 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 639 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 640 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 641 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 642 ctx.glBeginTransformFeedback(GL_TRIANGLES); 643 ctx.expectError(GL_NO_ERROR); 644 645 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices); 646 ctx.expectError(GL_INVALID_OPERATION); 647 648 ctx.glPauseTransformFeedback(); 649 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices); 650 ctx.expectError(GL_NO_ERROR); 651 652 ctx.glEndTransformFeedback(); 653 ctx.glDeleteBuffers(1, &buf); 654 ctx.glDeleteTransformFeedbacks(1, &tfID); 655 ctx.expectError(GL_NO_ERROR); 656 ctx.endSection(); 657 } 658 659 ctx.glUseProgram(0); 660 } 661 662 void draw_elements_base_vertex (NegativeTestContext& ctx) 663 { 664 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version."); 665 666 GLuint fbo = 0; 667 GLfloat vertices[1]; 668 669 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 670 ctx.glDrawElementsBaseVertex(-1, 1, GL_UNSIGNED_INT, vertices, 1); 671 ctx.expectError(GL_INVALID_ENUM); 672 ctx.endSection(); 673 674 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 675 ctx.glDrawElementsBaseVertex(GL_POINTS, 1, -1, vertices, 1); 676 ctx.expectError(GL_INVALID_ENUM); 677 ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_FLOAT, vertices, 1); 678 ctx.expectError(GL_INVALID_ENUM); 679 ctx.endSection(); 680 681 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 682 ctx.glDrawElementsBaseVertex(GL_POINTS, -1, GL_UNSIGNED_INT, vertices, 1); 683 ctx.expectError(GL_INVALID_VALUE); 684 ctx.endSection(); 685 686 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 687 ctx.glGenFramebuffers(1, &fbo); 688 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 689 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 690 ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_UNSIGNED_INT, vertices, 1); 691 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 692 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 693 ctx.glDeleteFramebuffers(1, &fbo); 694 ctx.endSection(); 695 } 696 697 void draw_arrays_instanced (NegativeTestContext& ctx) 698 { 699 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 700 GLuint fbo = 0; 701 map<string, string> args; 702 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 703 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 704 705 ctx.glUseProgram(program.getProgram()); 706 ctx.expectError(GL_NO_ERROR); 707 ctx.glVertexAttribDivisor(0, 1); 708 ctx.expectError(GL_NO_ERROR); 709 710 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 711 ctx.glDrawArraysInstanced(-1, 0, 1, 1); 712 ctx.expectError(GL_INVALID_ENUM); 713 ctx.endSection(); 714 715 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 716 ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1); 717 ctx.expectError(GL_INVALID_VALUE); 718 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1); 719 ctx.expectError(GL_INVALID_VALUE); 720 ctx.endSection(); 721 722 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 723 ctx.glGenFramebuffers(1, &fbo); 724 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 725 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 726 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1); 727 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 728 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 729 ctx.glDeleteFramebuffers(1, &fbo); 730 ctx.endSection(); 731 732 ctx.glUseProgram(0); 733 } 734 735 void draw_arrays_instanced_invalid_program (NegativeTestContext& ctx) 736 { 737 ctx.glUseProgram(0); 738 GLuint fbo = 0; 739 ctx.glVertexAttribDivisor(0, 1); 740 ctx.expectError(GL_NO_ERROR); 741 742 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 743 ctx.glDrawArraysInstanced(-1, 0, 1, 1); 744 ctx.expectError(GL_INVALID_ENUM); 745 ctx.endSection(); 746 747 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 748 ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1); 749 ctx.expectError(GL_INVALID_VALUE); 750 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1); 751 ctx.expectError(GL_INVALID_VALUE); 752 ctx.endSection(); 753 754 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 755 ctx.glGenFramebuffers(1, &fbo); 756 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 757 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 758 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1); 759 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 760 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 761 ctx.glDeleteFramebuffers(1, &fbo); 762 ctx.endSection(); 763 } 764 765 void draw_arrays_instanced_incomplete_primitive (NegativeTestContext& ctx) 766 { 767 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 768 GLuint fbo = 0; 769 map<string, string> args; 770 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 771 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 772 773 ctx.glVertexAttribDivisor(0, 1); 774 ctx.expectError(GL_NO_ERROR); 775 776 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 777 ctx.glDrawArraysInstanced(-1, 0, 1, 1); 778 ctx.expectError(GL_INVALID_ENUM); 779 ctx.endSection(); 780 781 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 782 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, -1, 1); 783 ctx.expectError(GL_INVALID_VALUE); 784 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, -1); 785 ctx.expectError(GL_INVALID_VALUE); 786 ctx.endSection(); 787 788 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 789 ctx.glGenFramebuffers(1, &fbo); 790 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 791 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 792 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, 1); 793 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 794 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 795 ctx.glDeleteFramebuffers(1, &fbo); 796 ctx.endSection(); 797 798 ctx.glUseProgram(0); 799 } 800 801 void draw_elements_instanced (NegativeTestContext& ctx) 802 { 803 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 804 GLuint fbo = 0; 805 GLuint buf = 0; 806 GLuint tfID = 0; 807 GLfloat vertices[1]; 808 map<string, string> args; 809 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 810 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 811 812 ctx.glUseProgram(program.getProgram()); 813 ctx.glVertexAttribDivisor(0, 1); 814 ctx.expectError(GL_NO_ERROR); 815 816 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 817 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1); 818 ctx.expectError(GL_INVALID_ENUM); 819 ctx.endSection(); 820 821 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 822 ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, vertices, 1); 823 ctx.expectError(GL_INVALID_ENUM); 824 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, vertices, 1); 825 ctx.expectError(GL_INVALID_ENUM); 826 ctx.endSection(); 827 828 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 829 ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1); 830 ctx.expectError(GL_INVALID_VALUE); 831 ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1); 832 ctx.expectError(GL_INVALID_VALUE); 833 ctx.endSection(); 834 835 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 836 ctx.glGenFramebuffers(1, &fbo); 837 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 838 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 839 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1); 840 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 841 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 842 ctx.glDeleteFramebuffers(1, &fbo); 843 ctx.endSection(); 844 845 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 846 { 847 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 848 const char* tfVarying = "gl_Position"; 849 850 ctx.glGenBuffers(1, &buf); 851 ctx.glGenTransformFeedbacks(1, &tfID); 852 853 ctx.glUseProgram(program.getProgram()); 854 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 855 ctx.glLinkProgram(program.getProgram()); 856 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 857 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 858 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 859 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 860 ctx.glBeginTransformFeedback(GL_POINTS); 861 ctx.expectError(GL_NO_ERROR); 862 863 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1); 864 ctx.expectError(GL_INVALID_OPERATION); 865 866 ctx.glPauseTransformFeedback(); 867 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1); 868 ctx.expectError(GL_NO_ERROR); 869 870 ctx.glEndTransformFeedback(); 871 ctx.glDeleteBuffers(1, &buf); 872 ctx.glDeleteTransformFeedbacks(1, &tfID); 873 ctx.expectError(GL_NO_ERROR); 874 ctx.endSection(); 875 } 876 877 ctx.glUseProgram(0); 878 } 879 880 void draw_elements_instanced_invalid_program (NegativeTestContext& ctx) 881 { 882 ctx.glUseProgram(0); 883 GLuint fbo = 0; 884 GLfloat vertices[1]; 885 ctx.glVertexAttribDivisor(0, 1); 886 ctx.expectError(GL_NO_ERROR); 887 888 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 889 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1); 890 ctx.expectError(GL_INVALID_ENUM); 891 ctx.endSection(); 892 893 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 894 ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, vertices, 1); 895 ctx.expectError(GL_INVALID_ENUM); 896 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, vertices, 1); 897 ctx.expectError(GL_INVALID_ENUM); 898 ctx.endSection(); 899 900 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 901 ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1); 902 ctx.expectError(GL_INVALID_VALUE); 903 ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1); 904 ctx.expectError(GL_INVALID_VALUE); 905 ctx.endSection(); 906 907 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 908 ctx.glGenFramebuffers(1, &fbo); 909 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 910 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 911 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1); 912 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 913 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 914 ctx.glDeleteFramebuffers(1, &fbo); 915 ctx.endSection(); 916 } 917 918 void draw_elements_instanced_incomplete_primitive (NegativeTestContext& ctx) 919 { 920 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 921 GLuint fbo = 0; 922 GLuint buf = 0; 923 GLuint tfID = 0; 924 GLfloat vertices[1]; 925 map<string, string> args; 926 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 927 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 928 929 ctx.glUseProgram(program.getProgram()); 930 ctx.glVertexAttribDivisor(0, 1); 931 ctx.expectError(GL_NO_ERROR); 932 933 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 934 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1); 935 ctx.expectError(GL_INVALID_ENUM); 936 ctx.endSection(); 937 938 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 939 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, -1, vertices, 1); 940 ctx.expectError(GL_INVALID_ENUM); 941 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_FLOAT, vertices, 1); 942 ctx.expectError(GL_INVALID_ENUM); 943 ctx.endSection(); 944 945 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 946 ctx.glDrawElementsInstanced(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, vertices, 1); 947 ctx.expectError(GL_INVALID_VALUE); 948 ctx.glDrawElementsInstanced(GL_TRIANGLES, 11, GL_UNSIGNED_BYTE, vertices, -1); 949 ctx.expectError(GL_INVALID_VALUE); 950 ctx.endSection(); 951 952 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 953 ctx.glGenFramebuffers(1, &fbo); 954 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 955 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 956 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1); 957 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 958 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 959 ctx.glDeleteFramebuffers(1, &fbo); 960 ctx.endSection(); 961 962 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 963 { 964 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 965 const char* tfVarying= "gl_Position"; 966 967 ctx.glGenBuffers(1, &buf); 968 ctx.glGenTransformFeedbacks(1, &tfID); 969 970 ctx.glUseProgram(program.getProgram()); 971 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 972 ctx.glLinkProgram(program.getProgram()); 973 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 974 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 975 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 976 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 977 ctx.glBeginTransformFeedback(GL_TRIANGLES); 978 ctx.expectError(GL_NO_ERROR); 979 980 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1); 981 ctx.expectError(GL_INVALID_OPERATION); 982 983 ctx.glPauseTransformFeedback(); 984 ctx.glDrawElementsInstanced (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1); 985 ctx.expectError(GL_NO_ERROR); 986 987 ctx.glEndTransformFeedback(); 988 ctx.glDeleteBuffers(1, &buf); 989 ctx.glDeleteTransformFeedbacks(1, &tfID); 990 ctx.expectError(GL_NO_ERROR); 991 ctx.endSection(); 992 } 993 994 ctx.glUseProgram(0); 995 } 996 997 void draw_elements_instanced_base_vertex (NegativeTestContext& ctx) 998 { 999 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version."); 1000 1001 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 1002 GLuint fbo = 0; 1003 GLfloat vertices[1]; 1004 map<string, string> args; 1005 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 1006 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 1007 1008 ctx.glUseProgram(program.getProgram()); 1009 ctx.glVertexAttribDivisor(0, 1); 1010 ctx.expectError(GL_NO_ERROR); 1011 1012 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 1013 ctx.glDrawElementsInstancedBaseVertex(-1, 1, GL_UNSIGNED_BYTE, vertices, 1, 1); 1014 ctx.expectError(GL_INVALID_ENUM); 1015 ctx.endSection(); 1016 1017 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 1018 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, -1, vertices, 1, 1); 1019 ctx.expectError(GL_INVALID_ENUM); 1020 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_FLOAT, vertices, 1, 1); 1021 ctx.expectError(GL_INVALID_ENUM); 1022 ctx.endSection(); 1023 1024 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative."); 1025 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1, 1); 1026 ctx.expectError(GL_INVALID_VALUE); 1027 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1, 1); 1028 ctx.expectError(GL_INVALID_VALUE); 1029 ctx.endSection(); 1030 1031 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 1032 ctx.glGenFramebuffers(1, &fbo); 1033 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1034 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 1035 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1, 1); 1036 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 1037 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1038 ctx.glDeleteFramebuffers(1, &fbo); 1039 ctx.endSection(); 1040 1041 ctx.glUseProgram(0); 1042 } 1043 1044 void draw_range_elements (NegativeTestContext& ctx) 1045 { 1046 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 1047 GLuint fbo = 0; 1048 GLuint buf = 0; 1049 GLuint tfID = 0; 1050 GLfloat vertices[1]; 1051 map<string, string> args; 1052 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 1053 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 1054 1055 ctx.glUseProgram(program.getProgram()); 1056 ctx.expectError(GL_NO_ERROR); 1057 1058 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 1059 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1060 ctx.expectError(GL_INVALID_ENUM); 1061 ctx.endSection(); 1062 1063 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 1064 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, vertices); 1065 ctx.expectError(GL_INVALID_ENUM); 1066 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices); 1067 ctx.expectError(GL_INVALID_ENUM); 1068 ctx.endSection(); 1069 1070 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 1071 ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices); 1072 ctx.expectError(GL_INVALID_VALUE); 1073 ctx.endSection(); 1074 1075 ctx.beginSection("GL_INVALID_VALUE is generated if end < start."); 1076 ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices); 1077 ctx.expectError(GL_INVALID_VALUE); 1078 ctx.endSection(); 1079 1080 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 1081 ctx.glGenFramebuffers(1, &fbo); 1082 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1083 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 1084 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1085 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 1086 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1087 ctx.glDeleteFramebuffers(1, &fbo); 1088 ctx.endSection(); 1089 1090 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 1091 { 1092 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 1093 const char* tfVarying= "gl_Position"; 1094 1095 ctx.glGenBuffers(1, &buf); 1096 ctx.glGenTransformFeedbacks(1, &tfID); 1097 1098 ctx.glUseProgram(program.getProgram()); 1099 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 1100 ctx.glLinkProgram(program.getProgram()); 1101 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 1102 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 1103 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 1104 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 1105 ctx.glBeginTransformFeedback(GL_POINTS); 1106 ctx.expectError(GL_NO_ERROR); 1107 1108 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1109 ctx.expectError(GL_INVALID_OPERATION); 1110 1111 ctx.glPauseTransformFeedback(); 1112 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1113 ctx.expectError(GL_NO_ERROR); 1114 1115 ctx.glEndTransformFeedback(); 1116 ctx.glDeleteBuffers(1, &buf); 1117 ctx.glDeleteTransformFeedbacks(1, &tfID); 1118 ctx.expectError(GL_NO_ERROR); 1119 ctx.endSection(); 1120 } 1121 1122 ctx.glUseProgram(0); 1123 } 1124 1125 void draw_range_elements_invalid_program (NegativeTestContext& ctx) 1126 { 1127 ctx.glUseProgram(0); 1128 GLuint fbo = 0; 1129 GLfloat vertices[1]; 1130 1131 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 1132 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1133 ctx.expectError(GL_INVALID_ENUM); 1134 ctx.endSection(); 1135 1136 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 1137 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, vertices); 1138 ctx.expectError(GL_INVALID_ENUM); 1139 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices); 1140 ctx.expectError(GL_INVALID_ENUM); 1141 ctx.endSection(); 1142 1143 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 1144 ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices); 1145 ctx.expectError(GL_INVALID_VALUE); 1146 ctx.endSection(); 1147 1148 ctx.beginSection("GL_INVALID_VALUE is generated if end < start."); 1149 ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices); 1150 ctx.expectError(GL_INVALID_VALUE); 1151 ctx.endSection(); 1152 1153 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 1154 ctx.glGenFramebuffers(1, &fbo); 1155 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1156 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 1157 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1158 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 1159 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1160 ctx.glDeleteFramebuffers(1, &fbo); 1161 ctx.endSection(); 1162 } 1163 1164 void draw_range_elements_incomplete_primitive (NegativeTestContext& ctx) 1165 { 1166 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 1167 GLuint fbo = 0; 1168 GLuint buf = 0; 1169 GLuint tfID = 0; 1170 GLfloat vertices[1]; 1171 map<string, string> args; 1172 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 1173 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 1174 1175 ctx.glUseProgram(program.getProgram()); 1176 ctx.expectError(GL_NO_ERROR); 1177 1178 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 1179 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1180 ctx.expectError(GL_INVALID_ENUM); 1181 ctx.endSection(); 1182 1183 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 1184 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, -1, vertices); 1185 ctx.expectError(GL_INVALID_ENUM); 1186 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_FLOAT, vertices); 1187 ctx.expectError(GL_INVALID_ENUM); 1188 ctx.endSection(); 1189 1190 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 1191 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, -1, GL_UNSIGNED_BYTE, vertices); 1192 ctx.expectError(GL_INVALID_VALUE); 1193 ctx.endSection(); 1194 1195 ctx.beginSection("GL_INVALID_VALUE is generated if end < start."); 1196 ctx.glDrawRangeElements(GL_TRIANGLES, 1, 0, 1, GL_UNSIGNED_BYTE, vertices); 1197 ctx.expectError(GL_INVALID_VALUE); 1198 ctx.endSection(); 1199 1200 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 1201 ctx.glGenFramebuffers(1, &fbo); 1202 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1203 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 1204 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1205 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 1206 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1207 ctx.glDeleteFramebuffers(1, &fbo); 1208 ctx.endSection(); 1209 1210 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error 1211 { 1212 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused."); 1213 const char* tfVarying = "gl_Position"; 1214 1215 ctx.glGenBuffers(1, &buf); 1216 ctx.glGenTransformFeedbacks(1, &tfID); 1217 1218 ctx.glUseProgram(program.getProgram()); 1219 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS); 1220 ctx.glLinkProgram(program.getProgram()); 1221 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); 1222 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf); 1223 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW); 1224 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); 1225 ctx.glBeginTransformFeedback(GL_TRIANGLES); 1226 ctx.expectError(GL_NO_ERROR); 1227 1228 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1229 ctx.expectError(GL_INVALID_OPERATION); 1230 1231 ctx.glPauseTransformFeedback(); 1232 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices); 1233 ctx.expectError(GL_NO_ERROR); 1234 1235 ctx.glEndTransformFeedback(); 1236 ctx.glDeleteBuffers(1, &buf); 1237 ctx.glDeleteTransformFeedbacks(1, &tfID); 1238 ctx.expectError(GL_NO_ERROR); 1239 ctx.endSection(); 1240 } 1241 1242 ctx.glUseProgram(0); 1243 } 1244 1245 void draw_range_elements_base_vertex (NegativeTestContext& ctx) 1246 { 1247 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version."); 1248 1249 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 1250 GLuint fbo = 0; 1251 GLfloat vertices[1]; 1252 map<string, string> args; 1253 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 1254 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args))); 1255 1256 ctx.glUseProgram(program.getProgram()); 1257 ctx.expectError(GL_NO_ERROR); 1258 1259 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value."); 1260 ctx.glDrawRangeElementsBaseVertex(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices, 1); 1261 ctx.expectError(GL_INVALID_ENUM); 1262 ctx.endSection(); 1263 1264 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values."); 1265 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, -1, vertices, 1); 1266 ctx.expectError(GL_INVALID_ENUM); 1267 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices, 1); 1268 ctx.expectError(GL_INVALID_ENUM); 1269 ctx.endSection(); 1270 1271 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative."); 1272 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices, 1); 1273 ctx.expectError(GL_INVALID_VALUE); 1274 ctx.endSection(); 1275 1276 ctx.beginSection("GL_INVALID_VALUE is generated if end < start."); 1277 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices, 1); 1278 ctx.expectError(GL_INVALID_VALUE); 1279 ctx.endSection(); 1280 1281 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 1282 ctx.glGenFramebuffers(1, &fbo); 1283 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1284 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 1285 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices, 1); 1286 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 1287 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1288 ctx.glDeleteFramebuffers(1, &fbo); 1289 ctx.endSection(); 1290 1291 ctx.glUseProgram(0); 1292 } 1293 1294 std::vector<FunctionContainer> getNegativeVertexArrayApiTestFunctions () 1295 { 1296 FunctionContainer funcs[] = 1297 { 1298 {vertex_attribf, "vertex_attribf", "Invalid glVertexAttrib{1234}f() usage" }, 1299 {vertex_attribfv, "vertex_attribfv", "Invalid glVertexAttrib{1234}fv() usage" }, 1300 {vertex_attribi4, "vertex_attribi4", "Invalid glVertexAttribI4{i|ui}f() usage" }, 1301 {vertex_attribi4v, "vertex_attribi4v", "Invalid glVertexAttribI4{i|ui}fv() usage" }, 1302 {vertex_attrib_pointer, "vertex_attrib_pointer", "Invalid glVertexAttribPointer() usage" }, 1303 {vertex_attrib_i_pointer, "vertex_attrib_i_pointer", "Invalid glVertexAttribPointer() usage" }, 1304 {vertex_attrib_format, "vertex_attrib_format", "Invalid glVertexAttribFormat() usage" }, 1305 {vertex_attrib_i_format, "vertex_attrib_i_format", "Invalid glVertexAttribIFormat() usage" }, 1306 {enable_vertex_attrib_array, "enable_vertex_attrib_array", "Invalid glEnableVertexAttribArray() usage" }, 1307 {disable_vertex_attrib_array, "disable_vertex_attrib_array", "Invalid glDisableVertexAttribArray() usage" }, 1308 {gen_vertex_arrays, "gen_vertex_arrays", "Invalid glGenVertexArrays() usage" }, 1309 {bind_vertex_array, "bind_vertex_array", "Invalid glBindVertexArray() usage" }, 1310 {delete_vertex_arrays, "delete_vertex_arrays", "Invalid glDeleteVertexArrays() usage" }, 1311 {vertex_attrib_divisor, "vertex_attrib_divisor", "Invalid glVertexAttribDivisor() usage" }, 1312 {draw_arrays, "draw_arrays", "Invalid glDrawArrays() usage" }, 1313 {draw_arrays_invalid_program, "draw_arrays_invalid_program", "Invalid glDrawArrays() usage" }, 1314 {draw_arrays_incomplete_primitive, "draw_arrays_incomplete_primitive", "Invalid glDrawArrays() usage" }, 1315 {draw_elements, "draw_elements", "Invalid glDrawElements() usage" }, 1316 {draw_elements_base_vertex, "draw_elements_base_vertex", "Invalid glDrawElementsBaseVertex() usage" }, 1317 {draw_elements_invalid_program, "draw_elements_invalid_program", "Invalid glDrawElements() usage" }, 1318 {draw_elements_incomplete_primitive, "draw_elements_incomplete_primitive", "Invalid glDrawElements() usage" }, 1319 {draw_arrays_instanced, "draw_arrays_instanced", "Invalid glDrawArraysInstanced() usage" }, 1320 {draw_arrays_instanced_invalid_program, "draw_arrays_instanced_invalid_program", "Invalid glDrawArraysInstanced() usage" }, 1321 {draw_arrays_instanced_incomplete_primitive, "draw_arrays_instanced_incomplete_primitive", "Invalid glDrawArraysInstanced() usage" }, 1322 {draw_elements_instanced, "draw_elements_instanced", "Invalid glDrawElementsInstanced() usage" }, 1323 {draw_elements_instanced_invalid_program, "draw_elements_instanced_invalid_program", "Invalid glDrawElementsInstanced() usage" }, 1324 {draw_elements_instanced_incomplete_primitive, "draw_elements_instanced_incomplete_primitive", "Invalid glDrawElementsInstanced() usage" }, 1325 {draw_elements_instanced_base_vertex, "draw_elements_instanced_base_vertex", "Invalid glDrawElementsInstancedBaseVertex() usage" }, 1326 {draw_range_elements, "draw_range_elements", "Invalid glDrawRangeElements() usage" }, 1327 {draw_range_elements_invalid_program, "draw_range_elements_invalid_program", "Invalid glDrawRangeElements() usage" }, 1328 {draw_range_elements_incomplete_primitive, "draw_range_elements_incomplete_primitive", "Invalid glDrawRangeElements() usage" }, 1329 {draw_range_elements_base_vertex, "draw_range_elements_base_vertex", "Invalid glDrawRangeElementsBaseVertex() usage" }, 1330 }; 1331 1332 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 1333 } 1334 1335 } // NegativeTestShared 1336 } // Functional 1337 } // gles31 1338 } // deqp 1339
