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 Buffer API tests. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es31fNegativeBufferApiTests.hpp" 25 26#include "gluCallLogWrapper.hpp" 27 28#include "glwDefs.hpp" 29#include "glwEnums.hpp" 30 31namespace deqp 32{ 33namespace gles31 34{ 35namespace Functional 36{ 37namespace NegativeTestShared 38{ 39 40using tcu::TestLog; 41using glu::CallLogWrapper; 42using namespace glw; 43 44// Buffers 45void bind_buffer (NegativeTestContext& ctx) 46{ 47 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the allowable values."); 48 ctx.glBindBuffer(-1, 0); 49 ctx.expectError(GL_INVALID_ENUM); 50 ctx.endSection(); 51} 52 53void delete_buffers (NegativeTestContext& ctx) 54{ 55 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 56 ctx.glDeleteBuffers(-1, 0); 57 ctx.expectError(GL_INVALID_VALUE); 58 ctx.endSection(); 59} 60 61void gen_buffers (NegativeTestContext& ctx) 62{ 63 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 64 ctx.glGenBuffers(-1, 0); 65 ctx.expectError(GL_INVALID_VALUE); 66 ctx.endSection(); 67} 68 69void buffer_data (NegativeTestContext& ctx) 70{ 71 GLuint buffer = 0x1234; 72 ctx.glGenBuffers(1, &buffer); 73 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer); 74 75 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER."); 76 ctx.glBufferData(-1, 0, NULL, GL_STREAM_DRAW); 77 ctx.expectError(GL_INVALID_ENUM); 78 ctx.endSection(); 79 80 ctx.beginSection("GL_INVALID_ENUM is generated if usage is not GL_STREAM_DRAW, GL_STATIC_DRAW, or GL_DYNAMIC_DRAW."); 81 ctx.glBufferData(GL_ARRAY_BUFFER, 0, NULL, -1); 82 ctx.expectError(GL_INVALID_ENUM); 83 ctx.endSection(); 84 85 ctx.beginSection("GL_INVALID_VALUE is generated if size is negative."); 86 ctx.glBufferData(GL_ARRAY_BUFFER, -1, NULL, GL_STREAM_DRAW); 87 ctx.expectError(GL_INVALID_VALUE); 88 ctx.endSection(); 89 90 ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target."); 91 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 92 ctx.glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STREAM_DRAW); 93 ctx.expectError(GL_INVALID_OPERATION); 94 ctx.endSection(); 95 96 ctx.glDeleteBuffers(1, &buffer); 97} 98 99void buffer_sub_data (NegativeTestContext& ctx) 100{ 101 GLuint buffer = 0x1234; 102 ctx.glGenBuffers(1, &buffer); 103 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer); 104 ctx.glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW); 105 106 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER."); 107 ctx.glBufferSubData(-1, 1, 1, 0); 108 ctx.expectError(GL_INVALID_ENUM); 109 ctx.endSection(); 110 111 ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target."); 112 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0); 113 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0); 114 ctx.expectError(GL_INVALID_OPERATION); 115 ctx.endSection(); 116 117 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer object being updated is mapped."); 118 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer); 119 ctx.glMapBufferRange(GL_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT); 120 ctx.expectError(GL_NO_ERROR); 121 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0); 122 ctx.expectError(GL_INVALID_OPERATION); 123 ctx.endSection(); 124 125 ctx.glDeleteBuffers(1, &buffer); 126} 127 128void buffer_sub_data_size_offset (NegativeTestContext& ctx) 129{ 130 GLuint buffer = 0x1234; 131 ctx.glGenBuffers(1, &buffer); 132 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer); 133 ctx.glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW); 134 135 ctx.beginSection("GL_INVALID_VALUE is generated if offset or size is negative, or if together they define a region of memory that extends beyond the buffer object's allocated data store."); 136 ctx.glBufferSubData(GL_ARRAY_BUFFER, -1, 1, 0); 137 ctx.expectError(GL_INVALID_VALUE); 138 ctx.glBufferSubData(GL_ARRAY_BUFFER, -1, -1, 0); 139 ctx.expectError(GL_INVALID_VALUE); 140 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, -1, 0); 141 ctx.expectError(GL_INVALID_VALUE); 142 ctx.glBufferSubData(GL_ARRAY_BUFFER, 15, 1, 0); 143 ctx.expectError(GL_INVALID_VALUE); 144 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 15, 0); 145 ctx.expectError(GL_INVALID_VALUE); 146 ctx.glBufferSubData(GL_ARRAY_BUFFER, 8, 8, 0); 147 ctx.expectError(GL_INVALID_VALUE); 148 ctx.endSection(); 149 150 ctx.glDeleteBuffers(1, &buffer); 151} 152 153void clear (NegativeTestContext& ctx) 154{ 155 ctx.beginSection("GL_INVALID_VALUE is generated if any bit other than the three defined bits is set in mask."); 156 ctx.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); 157 ctx.expectError(GL_NO_ERROR); 158 ctx.glClear(0x00000200); 159 ctx.expectError(GL_INVALID_VALUE); 160 ctx.glClear(0x00001000); 161 ctx.expectError(GL_INVALID_VALUE); 162 ctx.glClear(0x00000010); 163 ctx.expectError(GL_INVALID_VALUE); 164 ctx.endSection(); 165} 166 167void read_pixels (NegativeTestContext& ctx) 168{ 169 std::vector<GLubyte> ubyteData (4); 170 GLuint fbo = 0x1234; 171 172 ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of format and type is unsupported."); 173 ctx.glReadPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ubyteData[0]); 174 ctx.expectError(GL_INVALID_OPERATION); 175 ctx.endSection(); 176 177 ctx.beginSection("GL_INVALID_VALUE is generated if either width or height is negative."); 178 ctx.glReadPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 179 ctx.expectError(GL_INVALID_VALUE); 180 ctx.glReadPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 181 ctx.expectError(GL_INVALID_VALUE); 182 ctx.glReadPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 183 ctx.expectError(GL_INVALID_VALUE); 184 ctx.endSection(); 185 186 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 187 ctx.glGenFramebuffers(1, &fbo); 188 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 189 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 190 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 191 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 192 ctx.endSection(); 193 194 ctx.glDeleteFramebuffers(1, &fbo); 195} 196 197void readn_pixels (NegativeTestContext& ctx) 198{ 199 std::vector<GLfloat> floatData (4); 200 std::vector<GLubyte> ubyteData (4); 201 GLuint fbo = 0x1234; 202 203 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) 204 && !ctx.isExtensionSupported("GL_KHR_robustness") 205 && !ctx.isExtensionSupported("GL_EXT_robustness")) 206 { 207 TCU_THROW(NotSupportedError, "GLES 3.2 or robustness extension not supported"); 208 } 209 210 ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of format and type is unsupported."); 211 ctx.glReadnPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, (int) ubyteData.size(), &ubyteData[0]); 212 ctx.expectError(GL_INVALID_OPERATION); 213 ctx.endSection(); 214 215 ctx.beginSection("GL_INVALID_VALUE is generated if either width or height is negative."); 216 ctx.glReadnPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]); 217 ctx.expectError(GL_INVALID_VALUE); 218 ctx.glReadnPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]); 219 ctx.expectError(GL_INVALID_VALUE); 220 ctx.glReadnPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]); 221 ctx.expectError(GL_INVALID_VALUE); 222 ctx.endSection(); 223 224 ctx.beginSection("GL_INVALID_OPERATION is generated by ReadnPixels if the buffer size required to store the requested data is larger than bufSize."); 225 ctx.glReadnPixels(0, 0, 0x1234, 0x1234, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]); 226 ctx.expectError(GL_INVALID_OPERATION); 227 ctx.glReadnPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, (int) floatData.size(), &floatData[0]); 228 ctx.expectError(GL_INVALID_OPERATION); 229 ctx.endSection(); 230 231 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 232 ctx.glGenFramebuffers(1, &fbo); 233 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 234 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 235 ctx.glReadnPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]); 236 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 237 ctx.endSection(); 238 239 ctx.glDeleteFramebuffers(1, &fbo); 240} 241 242void read_pixels_format_mismatch (NegativeTestContext& ctx) 243{ 244 std::vector<GLubyte> ubyteData (4); 245 std::vector<GLushort> ushortData (4); 246 GLint readFormat = 0x1234; 247 GLint readType = 0x1234; 248 249 ctx.beginSection("Unsupported combinations of format and type will generate an GL_INVALID_OPERATION error."); 250 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]); 251 ctx.expectError(GL_INVALID_OPERATION); 252 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]); 253 ctx.expectError(GL_INVALID_OPERATION); 254 ctx.glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]); 255 ctx.expectError(GL_INVALID_OPERATION); 256 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]); 257 ctx.expectError(GL_INVALID_OPERATION); 258 ctx.glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]); 259 ctx.expectError(GL_INVALID_OPERATION); 260 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]); 261 ctx.expectError(GL_INVALID_OPERATION); 262 ctx.endSection(); 263 264 ctx.beginSection("GL_RGBA/GL_UNSIGNED_BYTE is always accepted and the other acceptable pair can be discovered by querying GL_IMPLEMENTATION_COLOR_READ_FORMAT and GL_IMPLEMENTATION_COLOR_READ_TYPE."); 265 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 266 ctx.expectError(GL_NO_ERROR); 267 ctx.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat); 268 ctx.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType); 269 ctx.glReadPixels(0, 0, 1, 1, readFormat, readType, &ubyteData[0]); 270 ctx.expectError(GL_NO_ERROR); 271 ctx.endSection(); 272} 273 274void read_pixels_fbo_format_mismatch (NegativeTestContext& ctx) 275{ 276 std::vector<GLubyte> ubyteData(4); 277 std::vector<float> floatData(4); 278 deUint32 fbo = 0x1234; 279 deUint32 texture = 0x1234; 280 281 ctx.glGenTextures (1, &texture); 282 ctx.glBindTexture (GL_TEXTURE_2D, texture); 283 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 284 ctx.glGenFramebuffers (1, &fbo); 285 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 286 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 287 ctx.expectError (GL_NO_ERROR); 288 289 ctx.beginSection("GL_INVALID_OPERATION is generated if currently bound framebuffer format is incompatible with format and type."); 290 291 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 292 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 293 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 294 ctx.expectError (GL_NO_ERROR); 295 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 296 ctx.expectError (GL_INVALID_OPERATION); 297 298 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 299 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 300 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 301 ctx.expectError (GL_NO_ERROR); 302 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 303 ctx.expectError (GL_INVALID_OPERATION); 304 305 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 306 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 307 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 308 ctx.expectError (GL_NO_ERROR); 309 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 310 ctx.expectError (GL_INVALID_OPERATION); 311 312 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || 313 ctx.isExtensionSupported("GL_EXT_color_buffer_float")) 314 { 315 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL); 316 ctx.expectError (GL_NO_ERROR); 317 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 318 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 319 ctx.expectError (GL_NO_ERROR); 320 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_INT, &floatData[0]); 321 ctx.expectError (GL_INVALID_OPERATION); 322 } 323 324 ctx.endSection(); 325 326 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_READ_FRAMEBUFFER_BINDING is non-zero, the read framebuffer is complete, and the value of GL_SAMPLE_BUFFERS for the read framebuffer is greater than zero."); 327 328 int binding = -1; 329 int sampleBuffers = 0x1234; 330 deUint32 rbo = 0x1234; 331 332 ctx.glGenRenderbuffers(1, &rbo); 333 ctx.glBindRenderbuffer(GL_RENDERBUFFER, rbo); 334 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 335 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo); 336 337 ctx.glGetIntegerv (GL_READ_FRAMEBUFFER_BINDING, &binding); 338 ctx.getLog() << TestLog::Message << "// GL_READ_FRAMEBUFFER_BINDING: " << binding << TestLog::EndMessage; 339 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 340 ctx.glGetIntegerv (GL_SAMPLE_BUFFERS, &sampleBuffers); 341 ctx.getLog() << TestLog::Message << "// GL_SAMPLE_BUFFERS: " << sampleBuffers << TestLog::EndMessage; 342 ctx.expectError (GL_NO_ERROR); 343 344 if (binding == 0 || sampleBuffers <= 0) 345 { 346 ctx.getLog() << TestLog::Message << "// ERROR: expected GL_READ_FRAMEBUFFER_BINDING to be non-zero and GL_SAMPLE_BUFFERS to be greater than zero" << TestLog::EndMessage; 347 ctx.fail("Got invalid value"); 348 } 349 else 350 { 351 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 352 ctx.expectError (GL_INVALID_OPERATION); 353 } 354 355 ctx.endSection(); 356 357 ctx.glBindRenderbuffer (GL_RENDERBUFFER, 0); 358 ctx.glBindTexture (GL_TEXTURE_2D, 0); 359 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 360 ctx.glDeleteFramebuffers (1, &fbo); 361 ctx.glDeleteTextures (1, &texture); 362 ctx.glDeleteRenderbuffers (1, &rbo); 363} 364 365void bind_buffer_range (NegativeTestContext& ctx) 366{ 367 deUint32 bufAC = 0x1234; 368 deUint32 bufU = 0x1234; 369 deUint32 bufTF = 0x1234; 370 int maxTFSize = 0x1234; 371 int maxUSize = 0x1234; 372 int uAlignment = 0x1234; 373 374 ctx.glGenBuffers(1, &bufU); 375 ctx.glBindBuffer(GL_UNIFORM_BUFFER, bufU); 376 ctx.glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW); 377 378 ctx.glGenBuffers(1, &bufTF); 379 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF); 380 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW); 381 382 ctx.glGenBuffers(1, &bufAC); 383 ctx.glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufAC); 384 ctx.glBufferData(GL_ATOMIC_COUNTER_BUFFER, 16, NULL, GL_STREAM_DRAW); 385 386 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ATOMIC_COUNTER_BUFFER, GL_SHADER_STORAGE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER."); 387 ctx.glBindBufferRange(GL_ARRAY_BUFFER, 0, bufU, 0, 4); 388 ctx.expectError(GL_INVALID_ENUM); 389 ctx.endSection(); 390 391 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and index is greater than or equal to GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."); 392 ctx.glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize); 393 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF, 0, 4); 394 ctx.expectError(GL_INVALID_VALUE); 395 ctx.endSection(); 396 397 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS."); 398 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize); 399 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, maxUSize, bufU, 0, 4); 400 ctx.expectError(GL_INVALID_VALUE); 401 ctx.endSection(); 402 403 ctx.beginSection("GL_INVALID_VALUE is generated if size is less than or equal to zero."); 404 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, -1); 405 ctx.expectError(GL_INVALID_VALUE); 406 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, 0); 407 ctx.expectError(GL_INVALID_VALUE); 408 ctx.endSection(); 409 410 ctx.beginSection("GL_INVALID_VALUE is generated if offset is less than zero."); 411 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, -1, 0); 412 ctx.expectError(GL_INVALID_VALUE); 413 ctx.endSection(); 414 415 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and size or offset are not multiples of 4."); 416 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 4, 5); 417 ctx.expectError(GL_INVALID_VALUE); 418 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 4); 419 ctx.expectError(GL_INVALID_VALUE); 420 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 7); 421 ctx.expectError(GL_INVALID_VALUE); 422 ctx.endSection(); 423 424 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and offset is not a multiple of GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT."); 425 ctx.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uAlignment); 426 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, uAlignment+1, 4); 427 ctx.expectError(GL_INVALID_VALUE); 428 ctx.endSection(); 429 430 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 431 { 432 int maxACize = 0x1234; 433 int maxSSize = 0x1234; 434 int ssAlignment = 0x1234; 435 436 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_ATOMIC_COUNTER_BUFFER and index is greater than or equal to GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS."); 437 ctx.glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &maxACize); 438 ctx.glBindBufferRange(GL_ATOMIC_COUNTER_BUFFER, maxACize, bufU, 0, 4); 439 ctx.expectError(GL_INVALID_VALUE); 440 ctx.endSection(); 441 442 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_SHADER_STORAGE_BUFFER and index is greater than or equal to GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS."); 443 ctx.glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxSSize); 444 ctx.glBindBufferRange(GL_SHADER_STORAGE_BUFFER, maxSSize, bufU, 0, 4); 445 ctx.expectError(GL_INVALID_VALUE); 446 ctx.endSection(); 447 448 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_ATOMIC_COUNTER_BUFFER and offset is not multiples of 4."); 449 ctx.glBindBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0, bufTF, 5, 4); 450 ctx.expectError(GL_INVALID_VALUE); 451 ctx.endSection(); 452 453 ctx.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &ssAlignment); 454 455 if (ssAlignment != 1) 456 { 457 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_SHADER_STORAGE_BUFFER and offset is not a multiple of the value of GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT."); 458 ctx.glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, bufTF, ssAlignment+1, 4); 459 ctx.expectError(GL_INVALID_VALUE); 460 ctx.endSection(); 461 } 462 } 463 464 ctx.glDeleteBuffers(1, &bufU); 465 ctx.glDeleteBuffers(1, &bufTF); 466 ctx.glDeleteBuffers(1, &bufAC); 467} 468 469void bind_buffer_base (NegativeTestContext& ctx) 470{ 471 deUint32 bufU = 0x1234; 472 deUint32 bufTF = 0x1234; 473 int maxUSize = 0x1234; 474 int maxTFSize = 0x1234; 475 476 ctx.glGenBuffers(1, &bufU); 477 ctx.glBindBuffer(GL_UNIFORM_BUFFER, bufU); 478 ctx.glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW); 479 480 ctx.glGenBuffers(1, &bufTF); 481 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF); 482 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW); 483 ctx.expectError(GL_NO_ERROR); 484 485 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ATOMIC_COUNTER_BUFFER, GL_SHADER_STORAGE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER."); 486 ctx.glBindBufferBase(-1, 0, bufU); 487 ctx.expectError(GL_INVALID_ENUM); 488 ctx.glBindBufferBase(GL_ARRAY_BUFFER, 0, bufU); 489 ctx.expectError(GL_INVALID_ENUM); 490 ctx.endSection(); 491 492 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS."); 493 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize); 494 ctx.glBindBufferBase(GL_UNIFORM_BUFFER, maxUSize, bufU); 495 ctx.expectError(GL_INVALID_VALUE); 496 ctx.endSection(); 497 498 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER andindex is greater than or equal to GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."); 499 ctx.glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize); 500 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF); 501 ctx.expectError(GL_INVALID_VALUE); 502 ctx.endSection(); 503 504 ctx.glDeleteBuffers(1, &bufU); 505 ctx.glDeleteBuffers(1, &bufTF); 506} 507 508void clear_bufferiv (NegativeTestContext& ctx) 509{ 510 std::vector<int> data (32*32); 511 deUint32 fbo = 0x1234; 512 deUint32 texture = 0x1234; 513 int maxDrawBuffers = 0x1234; 514 515 ctx.glGenTextures (1, &texture); 516 ctx.glBindTexture (GL_TEXTURE_2D, texture); 517 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 518 ctx.glGenFramebuffers (1, &fbo); 519 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 520 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 521 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 522 ctx.expectError (GL_NO_ERROR); 523 524 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not an accepted value."); 525 ctx.glClearBufferiv (-1, 0, &data[0]); 526 ctx.expectError (GL_INVALID_ENUM); 527 ctx.glClearBufferiv (GL_FRAMEBUFFER, 0, &data[0]); 528 ctx.expectError (GL_INVALID_ENUM); 529 ctx.endSection(); 530 531 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_DEPTH or GL_DEPTH_STENCIL."); 532 ctx.glClearBufferiv (GL_DEPTH, 1, &data[0]); 533 ctx.expectError (GL_INVALID_ENUM); 534 ctx.glClearBufferiv (GL_DEPTH_STENCIL, 1, &data[0]); 535 ctx.expectError (GL_INVALID_ENUM); 536 ctx.endSection(); 537 538 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR or GL_STENCIL and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 539 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 540 ctx.glClearBufferiv (GL_COLOR, maxDrawBuffers, &data[0]); 541 ctx.expectError (GL_INVALID_VALUE); 542 ctx.endSection(); 543 544 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR or GL_STENCIL and drawBuffer is negative."); 545 ctx.glClearBufferiv (GL_COLOR, -1, &data[0]); 546 ctx.expectError (GL_INVALID_VALUE); 547 ctx.endSection(); 548 549 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_STENCIL and drawBuffer is not zero."); 550 ctx.glClearBufferiv (GL_STENCIL, 1, &data[0]); 551 ctx.expectError (GL_INVALID_VALUE); 552 ctx.endSection(); 553 554 ctx.glDeleteFramebuffers (1, &fbo); 555 ctx.glDeleteTextures (1, &texture); 556} 557 558void clear_bufferuiv (NegativeTestContext& ctx) 559{ 560 std::vector<deUint32> data (32*32); 561 deUint32 fbo = 0x1234; 562 deUint32 texture = 0x1234; 563 int maxDrawBuffers = 0x1234; 564 565 ctx.glGenTextures (1, &texture); 566 ctx.glBindTexture (GL_TEXTURE_2D, texture); 567 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 568 ctx.glGenFramebuffers (1, &fbo); 569 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 570 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 571 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 572 ctx.expectError (GL_NO_ERROR); 573 574 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_COLOR."); 575 ctx.glClearBufferuiv (-1, 0, &data[0]); 576 ctx.expectError (GL_INVALID_ENUM); 577 ctx.glClearBufferuiv (GL_FRAMEBUFFER, 0, &data[0]); 578 ctx.expectError (GL_INVALID_ENUM); 579 ctx.endSection(); 580 581 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_DEPTH, GL_STENCIL, or GL_DEPTH_STENCIL."); 582 ctx.glClearBufferuiv (GL_DEPTH, 0, &data[0]); 583 ctx.expectError (GL_INVALID_ENUM); 584 ctx.glClearBufferuiv (GL_STENCIL, 0, &data[0]); 585 ctx.expectError (GL_INVALID_ENUM); 586 ctx.glClearBufferuiv (GL_DEPTH_STENCIL, 0, &data[0]); 587 ctx.expectError (GL_INVALID_ENUM); 588 ctx.endSection(); 589 590 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 591 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 592 ctx.glClearBufferuiv (GL_COLOR, maxDrawBuffers, &data[0]); 593 ctx.expectError (GL_INVALID_VALUE); 594 ctx.endSection(); 595 596 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is negative."); 597 ctx.glClearBufferuiv (GL_COLOR, -1, &data[0]); 598 ctx.expectError (GL_INVALID_VALUE); 599 ctx.endSection(); 600 601 ctx.glDeleteFramebuffers (1, &fbo); 602 ctx.glDeleteTextures (1, &texture); 603} 604 605void clear_bufferfv (NegativeTestContext& ctx) 606{ 607 std::vector<float> data (32*32); 608 deUint32 fbo = 0x1234; 609 deUint32 texture = 0x1234; 610 int maxDrawBuffers = 0x1234; 611 612 ctx.glGenTextures (1, &texture); 613 ctx.glBindTexture (GL_TEXTURE_2D, texture); 614 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL); 615 ctx.glGenFramebuffers (1, &fbo); 616 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 617 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 618 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 619 ctx.expectError (GL_NO_ERROR); 620 621 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_COLOR or GL_DEPTH."); 622 ctx.glClearBufferfv (-1, 0, &data[0]); 623 ctx.expectError (GL_INVALID_ENUM); 624 ctx.glClearBufferfv (GL_FRAMEBUFFER, 0, &data[0]); 625 ctx.expectError (GL_INVALID_ENUM); 626 ctx.endSection(); 627 628 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_STENCIL or GL_DEPTH_STENCIL."); 629 ctx.glClearBufferfv (GL_STENCIL, 1, &data[0]); 630 ctx.expectError (GL_INVALID_ENUM); 631 ctx.glClearBufferfv (GL_DEPTH_STENCIL, 1, &data[0]); 632 ctx.expectError (GL_INVALID_ENUM); 633 ctx.endSection(); 634 635 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 636 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 637 ctx.glClearBufferfv (GL_COLOR, maxDrawBuffers, &data[0]); 638 ctx.expectError (GL_INVALID_VALUE); 639 ctx.endSection(); 640 641 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is negative."); 642 ctx.glClearBufferfv (GL_COLOR, -1, &data[0]); 643 ctx.expectError (GL_INVALID_VALUE); 644 ctx.endSection(); 645 646 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_DEPTH and drawBuffer is not zero."); 647 ctx.glClearBufferfv (GL_DEPTH, 1, &data[0]); 648 ctx.expectError (GL_INVALID_VALUE); 649 ctx.endSection(); 650 651 ctx.glDeleteFramebuffers (1, &fbo); 652 ctx.glDeleteTextures (1, &texture); 653} 654 655void clear_bufferfi (NegativeTestContext& ctx) 656{ 657 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_DEPTH_STENCIL."); 658 ctx.glClearBufferfi (-1, 0, 1.0f, 1); 659 ctx.expectError (GL_INVALID_ENUM); 660 ctx.glClearBufferfi (GL_FRAMEBUFFER, 0, 1.0f, 1); 661 ctx.expectError (GL_INVALID_ENUM); 662 ctx.glClearBufferfi (GL_DEPTH, 0, 1.0f, 1); 663 ctx.expectError (GL_INVALID_ENUM); 664 ctx.glClearBufferfi (GL_STENCIL, 0, 1.0f, 1); 665 ctx.expectError (GL_INVALID_ENUM); 666 ctx.glClearBufferfi (GL_COLOR, 0, 1.0f, 1); 667 ctx.expectError (GL_INVALID_ENUM); 668 ctx.endSection(); 669 670 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_DEPTH_STENCIL and drawBuffer is not zero."); 671 ctx.glClearBufferfi (GL_DEPTH_STENCIL, 1, 1.0f, 1); 672 ctx.expectError (GL_INVALID_VALUE); 673 ctx.endSection(); 674} 675 676void copy_buffer_sub_data (NegativeTestContext& ctx) 677{ 678 deUint32 buf[2]; 679 std::vector<float> data (32*32); 680 681 ctx.glGenBuffers (2, buf); 682 ctx.glBindBuffer (GL_COPY_READ_BUFFER, buf[0]); 683 ctx.glBufferData (GL_COPY_READ_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 684 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 685 ctx.glBufferData (GL_COPY_WRITE_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 686 ctx.expectError (GL_NO_ERROR); 687 688 ctx.beginSection("GL_INVALID_VALUE is generated if any of readoffset, writeoffset or size is negative."); 689 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, -4); 690 ctx.expectError (GL_INVALID_VALUE); 691 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, -1, 0, 4); 692 ctx.expectError (GL_INVALID_VALUE); 693 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, -1, 4); 694 ctx.expectError (GL_INVALID_VALUE); 695 ctx.endSection(); 696 697 ctx.beginSection("GL_INVALID_VALUE is generated if readoffset + size exceeds the size of the buffer object bound to readtarget."); 698 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36); 699 ctx.expectError (GL_INVALID_VALUE); 700 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 24, 0, 16); 701 ctx.expectError (GL_INVALID_VALUE); 702 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 36, 0, 4); 703 ctx.expectError (GL_INVALID_VALUE); 704 ctx.endSection(); 705 706 ctx.beginSection("GL_INVALID_VALUE is generated if writeoffset + size exceeds the size of the buffer object bound to writetarget."); 707 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36); 708 ctx.expectError (GL_INVALID_VALUE); 709 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 24, 16); 710 ctx.expectError (GL_INVALID_VALUE); 711 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 36, 4); 712 ctx.expectError (GL_INVALID_VALUE); 713 ctx.endSection(); 714 715 ctx.beginSection("GL_INVALID_VALUE is generated if the same buffer object is bound to both readtarget and writetarget and the ranges [readoffset, readoffset + size) and [writeoffset, writeoffset + size) overlap."); 716 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[0]); 717 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 4); 718 ctx.expectError (GL_NO_ERROR); 719 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 4); 720 ctx.expectError (GL_INVALID_VALUE); 721 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 18); 722 ctx.expectError (GL_INVALID_VALUE); 723 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 724 ctx.endSection(); 725 726 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to readtarget or writetarget."); 727 ctx.glBindBuffer (GL_COPY_READ_BUFFER, 0); 728 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 729 ctx.expectError (GL_INVALID_OPERATION); 730 731 ctx.glBindBuffer (GL_COPY_READ_BUFFER, buf[0]); 732 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, 0); 733 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 734 ctx.expectError (GL_INVALID_OPERATION); 735 736 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 737 ctx.endSection(); 738 739 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer object bound to either readtarget or writetarget is mapped."); 740 ctx.glMapBufferRange (GL_COPY_READ_BUFFER, 0, 4, GL_MAP_READ_BIT); 741 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 742 ctx.expectError (GL_INVALID_OPERATION); 743 ctx.glUnmapBuffer (GL_COPY_READ_BUFFER); 744 745 ctx.glMapBufferRange (GL_COPY_WRITE_BUFFER, 0, 4, GL_MAP_READ_BIT); 746 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 747 ctx.expectError (GL_INVALID_OPERATION); 748 ctx.glUnmapBuffer (GL_COPY_WRITE_BUFFER); 749 ctx.endSection(); 750 751 ctx.glDeleteBuffers(2, buf); 752} 753 754void draw_buffers (NegativeTestContext& ctx) 755{ 756 deUint32 fbo = 0x1234; 757 deUint32 texture = 0x1234; 758 int maxDrawBuffers = 0x1234; 759 int maxColorAttachments = -1; 760 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 761 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 762 std::vector<deUint32> values (maxDrawBuffers+1); 763 std::vector<deUint32> attachments (4); 764 std::vector<GLfloat> data (32*32); 765 values[0] = GL_NONE; 766 values[1] = GL_BACK; 767 values[2] = GL_COLOR_ATTACHMENT0; 768 values[3] = GL_DEPTH_ATTACHMENT; 769 attachments[0] = (glw::GLenum) (GL_COLOR_ATTACHMENT0 + maxColorAttachments); 770 attachments[1] = GL_COLOR_ATTACHMENT0; 771 attachments[2] = GL_COLOR_ATTACHMENT1; 772 attachments[3] = GL_NONE; 773 774 ctx.glGenTextures (1, &texture); 775 ctx.glBindTexture (GL_TEXTURE_2D, texture); 776 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 777 ctx.glGenFramebuffers (1, &fbo); 778 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 779 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 780 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 781 ctx.expectError (GL_NO_ERROR); 782 783 ctx.beginSection("GL_INVALID_ENUM is generated if one of the values in bufs is not an accepted value."); 784 ctx.glDrawBuffers (2, &values[2]); 785 ctx.expectError (GL_INVALID_ENUM); 786 ctx.endSection(); 787 788 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to a draw framebuffer and DrawBuffers is supplied with BACK or COLOR_ATTACHMENTm where m is greater than or equal to the value of MAX_COLOR_ATTACHMENTS."); 789 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 790 ctx.glDrawBuffers (1, &values[1]); 791 ctx.expectError (GL_INVALID_OPERATION); 792 ctx.glDrawBuffers (4, &attachments[0]); 793 ctx.expectError (GL_INVALID_OPERATION); 794 ctx.endSection(); 795 796 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and n is not 1."); 797 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 798 ctx.glDrawBuffers (2, &values[0]); 799 ctx.expectError (GL_INVALID_OPERATION); 800 ctx.endSection(); 801 802 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and the value in bufs is one of the GL_COLOR_ATTACHMENTn tokens."); 803 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 804 ctx.glDrawBuffers (1, &values[2]); 805 ctx.expectError (GL_INVALID_OPERATION); 806 ctx.endSection(); 807 808 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to a framebuffer object and the ith buffer listed in bufs is anything other than GL_NONE or GL_COLOR_ATTACHMENTSi."); 809 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 810 ctx.glDrawBuffers (1, &values[1]); 811 ctx.expectError (GL_INVALID_OPERATION); 812 ctx.glDrawBuffers (4, &attachments[0]); 813 ctx.expectError (GL_INVALID_OPERATION); 814 815 ctx.endSection(); 816 817 ctx.beginSection("GL_INVALID_VALUE is generated if n is less than 0 or greater than GL_MAX_DRAW_BUFFERS."); 818 ctx.glDrawBuffers (-1, &values[1]); 819 ctx.expectError (GL_INVALID_VALUE); 820 ctx.glDrawBuffers (maxDrawBuffers+1, &values[0]); 821 ctx.expectError (GL_INVALID_VALUE); 822 ctx.endSection(); 823 824 ctx.glDeleteTextures(1, &texture); 825 ctx.glDeleteFramebuffers(1, &fbo); 826} 827 828void flush_mapped_buffer_range (NegativeTestContext& ctx) 829{ 830 deUint32 buf = 0x1234; 831 std::vector<GLfloat> data (32); 832 833 ctx.glGenBuffers (1, &buf); 834 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf); 835 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_STATIC_READ); 836 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 837 ctx.expectError (GL_NO_ERROR); 838 839 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted values."); 840 ctx.glFlushMappedBufferRange(-1, 0, 16); 841 ctx.expectError (GL_INVALID_ENUM); 842 ctx.endSection(); 843 844 ctx.beginSection("GL_INVALID_VALUE is generated if offset or length is negative, or if offset + length exceeds the size of the mapping."); 845 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, -1, 1); 846 ctx.expectError (GL_INVALID_VALUE); 847 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, -1); 848 ctx.expectError (GL_INVALID_VALUE); 849 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 12, 8); 850 ctx.expectError (GL_INVALID_VALUE); 851 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 24, 4); 852 ctx.expectError (GL_INVALID_VALUE); 853 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 24); 854 ctx.expectError (GL_INVALID_VALUE); 855 ctx.endSection(); 856 857 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target."); 858 ctx.glBindBuffer (GL_ARRAY_BUFFER, 0); 859 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 860 ctx.expectError (GL_INVALID_OPERATION); 861 ctx.endSection(); 862 863 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer bound to target is not mapped, or is mapped without the GL_MAP_FLUSH_EXPLICIT flag."); 864 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf); 865 ctx.glUnmapBuffer (GL_ARRAY_BUFFER); 866 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 867 ctx.expectError (GL_INVALID_OPERATION); 868 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT); 869 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 870 ctx.expectError (GL_INVALID_OPERATION); 871 ctx.endSection(); 872 873 ctx.glUnmapBuffer (GL_ARRAY_BUFFER); 874 ctx.glDeleteBuffers (1, &buf); 875} 876 877void map_buffer_range (NegativeTestContext& ctx) 878{ 879 deUint32 buf = 0x1234; 880 std::vector<GLfloat> data (32); 881 882 ctx.glGenBuffers (1, &buf); 883 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf); 884 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 885 ctx.expectError (GL_NO_ERROR); 886 887 ctx.beginSection("GL_INVALID_VALUE is generated if either of offset or length is negative."); 888 ctx.glMapBufferRange (GL_ARRAY_BUFFER, -1, 1, GL_MAP_READ_BIT); 889 ctx.expectError (GL_INVALID_VALUE); 890 891 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 1, -1, GL_MAP_READ_BIT); 892 ctx.expectError (GL_INVALID_VALUE); 893 ctx.endSection(); 894 895 ctx.beginSection("GL_INVALID_VALUE is generated if offset + length is greater than the value of GL_BUFFER_SIZE."); 896 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 33, GL_MAP_READ_BIT); 897 ctx.expectError (GL_INVALID_VALUE); 898 899 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 32, 1, GL_MAP_READ_BIT); 900 ctx.expectError (GL_INVALID_VALUE); 901 902 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 16, 17, GL_MAP_READ_BIT); 903 ctx.expectError (GL_INVALID_VALUE); 904 ctx.endSection(); 905 906 ctx.beginSection("GL_INVALID_VALUE is generated if access has any bits set other than those accepted."); 907 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | 0x1000); 908 ctx.expectError (GL_INVALID_VALUE); 909 910 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | 0x1000); 911 ctx.expectError (GL_INVALID_VALUE); 912 ctx.endSection(); 913 914 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer is already in a mapped state."); 915 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT); 916 ctx.expectError (GL_NO_ERROR); 917 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 16, 8, GL_MAP_READ_BIT); 918 ctx.expectError (GL_INVALID_OPERATION); 919 ctx.glUnmapBuffer (GL_ARRAY_BUFFER); 920 ctx.endSection(); 921 922 ctx.beginSection("GL_INVALID_OPERATION is generated if neither GL_MAP_READ_BIT or GL_MAP_WRITE_BIT is set."); 923 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT); 924 ctx.expectError (GL_INVALID_OPERATION); 925 ctx.endSection(); 926 927 ctx.beginSection("GL_INVALID_OPERATION is generated if length is 0"); 928 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 0, GL_MAP_READ_BIT); 929 ctx.expectError (GL_INVALID_OPERATION); 930 ctx.endSection(); 931 932 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_MAP_READ_BIT is set and any of GL_MAP_INVALIDATE_RANGE_BIT, GL_MAP_INVALIDATE_BUFFER_BIT, or GL_MAP_UNSYNCHRONIZED_BIT is set."); 933 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT); 934 ctx.expectError (GL_INVALID_OPERATION); 935 936 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); 937 ctx.expectError (GL_INVALID_OPERATION); 938 939 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_UNSYNCHRONIZED_BIT); 940 ctx.expectError (GL_INVALID_OPERATION); 941 ctx.endSection(); 942 943 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_MAP_FLUSH_EXPLICIT_BIT is set and GL_MAP_WRITE_BIT is not set."); 944 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 945 ctx.expectError (GL_INVALID_OPERATION); 946 ctx.endSection(); 947 948 ctx.glDeleteBuffers (1, &buf); 949} 950 951void read_buffer (NegativeTestContext& ctx) 952{ 953 deUint32 fbo = 0x1234; 954 deUint32 texture = 0x1234; 955 int maxColorAttachments = 0x1234; 956 957 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 958 ctx.glGenTextures (1, &texture); 959 ctx.glBindTexture (GL_TEXTURE_2D, texture); 960 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 961 ctx.glGenFramebuffers (1, &fbo); 962 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 963 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 964 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER); 965 ctx.expectError (GL_NO_ERROR); 966 967 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not GL_BACK, GL_NONE, or GL_COLOR_ATTACHMENTi."); 968 ctx.glReadBuffer (GL_NONE); 969 ctx.expectError (GL_NO_ERROR); 970 ctx.glReadBuffer (1); 971 ctx.expectError (GL_INVALID_ENUM); 972 ctx.glReadBuffer (GL_FRAMEBUFFER); 973 ctx.expectError (GL_INVALID_ENUM); 974 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0 - 1); 975 ctx.expectError (GL_INVALID_ENUM); 976 ctx.glReadBuffer (GL_FRONT); 977 ctx.expectError (GL_INVALID_ENUM); 978 979 // \ note Spec isn't actually clear here, but it is safe to assume that 980 // GL_DEPTH_ATTACHMENT can't be interpreted as GL_COLOR_ATTACHMENTm 981 // where m = (GL_DEPTH_ATTACHMENT - GL_COLOR_ATTACHMENT0). 982 ctx.glReadBuffer (GL_DEPTH_ATTACHMENT); 983 ctx.expectError (GL_INVALID_ENUM); 984 ctx.glReadBuffer (GL_STENCIL_ATTACHMENT); 985 ctx.expectError (GL_INVALID_ENUM); 986 ctx.glReadBuffer (GL_STENCIL_ATTACHMENT+1); 987 ctx.expectError (GL_INVALID_ENUM); 988 ctx.glReadBuffer (0xffffffffu); 989 ctx.expectError (GL_INVALID_ENUM); 990 ctx.endSection(); 991 992 ctx.beginSection("GL_INVALID_OPERATION error is generated if src is GL_BACK or if src is GL_COLOR_ATTACHMENTm where m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS."); 993 ctx.glReadBuffer (GL_BACK); 994 ctx.expectError (GL_INVALID_OPERATION); 995 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0 + maxColorAttachments); 996 ctx.expectError (GL_INVALID_OPERATION); 997 998 if (GL_COLOR_ATTACHMENT0+maxColorAttachments < GL_DEPTH_ATTACHMENT-1) 999 { 1000 ctx.glReadBuffer (GL_DEPTH_ATTACHMENT - 1); 1001 ctx.expectError (GL_INVALID_OPERATION); 1002 } 1003 1004 ctx.endSection(); 1005 1006 ctx.beginSection("GL_INVALID_OPERATION is generated if the current framebuffer is the default framebuffer and mode is not GL_NONE or GL_BACK."); 1007 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1008 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0); 1009 ctx.expectError (GL_INVALID_OPERATION); 1010 ctx.endSection(); 1011 1012 ctx.beginSection("GL_INVALID_OPERATION is generated if the current framebuffer is a named framebuffer and mode is not GL_NONE or GL_COLOR_ATTACHMENTi."); 1013 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1014 ctx.glReadBuffer (GL_BACK); 1015 ctx.expectError (GL_INVALID_OPERATION); 1016 ctx.endSection(); 1017 1018 ctx.glDeleteTextures(1, &texture); 1019 ctx.glDeleteFramebuffers(1, &fbo); 1020} 1021 1022void unmap_buffer (NegativeTestContext& ctx) 1023{ 1024 deUint32 buf = 0x1234; 1025 std::vector<GLfloat> data (32); 1026 1027 ctx.glGenBuffers (1, &buf); 1028 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf); 1029 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 1030 ctx.expectError (GL_NO_ERROR); 1031 1032 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer data store is already in an unmapped state."); 1033 ctx.glUnmapBuffer (GL_ARRAY_BUFFER); 1034 ctx.expectError (GL_INVALID_OPERATION); 1035 ctx.endSection(); 1036 1037 ctx.glDeleteBuffers (1, &buf); 1038} 1039// Framebuffer Objects 1040 1041void bind_framebuffer (NegativeTestContext& ctx) 1042{ 1043 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, or GL_FRAMEBUFFER."); 1044 ctx.glBindFramebuffer(-1, 0); 1045 ctx.expectError(GL_INVALID_ENUM); 1046 ctx.glBindFramebuffer(GL_RENDERBUFFER, 0); 1047 ctx.expectError(GL_INVALID_ENUM); 1048 ctx.endSection(); 1049} 1050 1051void bind_renderbuffer (NegativeTestContext& ctx) 1052{ 1053 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 1054 ctx.glBindRenderbuffer(-1, 0); 1055 ctx.expectError(GL_INVALID_ENUM); 1056 ctx.glBindRenderbuffer(GL_FRAMEBUFFER, 0); 1057 ctx.expectError(GL_INVALID_ENUM); 1058 ctx.endSection(); 1059} 1060 1061void check_framebuffer_status (NegativeTestContext& ctx) 1062{ 1063 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, or GL_FRAMEBUFFER.."); 1064 ctx.glCheckFramebufferStatus(-1); 1065 ctx.expectError(GL_INVALID_ENUM); 1066 ctx.glCheckFramebufferStatus(GL_RENDERBUFFER); 1067 ctx.expectError(GL_INVALID_ENUM); 1068 ctx.endSection(); 1069} 1070 1071void gen_framebuffers (NegativeTestContext& ctx) 1072{ 1073 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1074 ctx.glGenFramebuffers(-1, 0); 1075 ctx.expectError(GL_INVALID_VALUE); 1076 ctx.endSection(); 1077} 1078 1079void gen_renderbuffers (NegativeTestContext& ctx) 1080{ 1081 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1082 ctx.glGenRenderbuffers(-1, 0); 1083 ctx.expectError(GL_INVALID_VALUE); 1084 ctx.endSection(); 1085} 1086 1087void delete_framebuffers (NegativeTestContext& ctx) 1088{ 1089 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1090 ctx.glDeleteFramebuffers(-1, 0); 1091 ctx.expectError(GL_INVALID_VALUE); 1092 ctx.endSection(); 1093} 1094 1095void delete_renderbuffers (NegativeTestContext& ctx) 1096{; 1097 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative."); 1098 ctx.glDeleteRenderbuffers(-1, 0); 1099 ctx.expectError(GL_INVALID_VALUE); 1100 ctx.endSection(); 1101} 1102 1103void framebuffer_renderbuffer (NegativeTestContext& ctx) 1104{ 1105 GLuint fbo = 0x1234; 1106 GLuint rbo = 0x1234; 1107 ctx.glGenFramebuffers(1, &fbo); 1108 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1109 ctx.glGenRenderbuffers(1, &rbo); 1110 1111 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 1112 ctx.glFramebufferRenderbuffer(-1, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); 1113 ctx.expectError(GL_INVALID_ENUM); 1114 ctx.endSection(); 1115 1116 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens."); 1117 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, -1, GL_RENDERBUFFER, 0); 1118 ctx.expectError(GL_INVALID_ENUM); 1119 ctx.endSection(); 1120 1121 ctx.beginSection("GL_INVALID_ENUM is generated if renderbuffertarget is not GL_RENDERBUFFER."); 1122 ctx.glBindRenderbuffer(GL_RENDERBUFFER, rbo); 1123 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, rbo); 1124 ctx.expectError(GL_INVALID_ENUM); 1125 ctx.glBindRenderbuffer(GL_RENDERBUFFER, 0); 1126 ctx.endSection(); 1127 1128 ctx.beginSection("GL_INVALID_OPERATION is generated if renderbuffer is neither 0 nor the name of an existing renderbuffer object."); 1129 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, -1); 1130 ctx.expectError(GL_INVALID_OPERATION); 1131 ctx.endSection(); 1132 1133 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target."); 1134 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1135 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); 1136 ctx.expectError(GL_INVALID_OPERATION); 1137 ctx.endSection(); 1138 1139 ctx.glDeleteRenderbuffers(1, &rbo); 1140 ctx.glDeleteFramebuffers(1, &fbo); 1141} 1142 1143void framebuffer_texture (NegativeTestContext& ctx) 1144{ 1145 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1146 { 1147 GLuint fbo = 0x1234; 1148 GLuint texture[] = {0x1234, 0x1234}; 1149 1150 ctx.glGenFramebuffers(1, &fbo); 1151 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1152 ctx.glGenTextures(2, texture); 1153 ctx.glBindTexture(GL_TEXTURE_2D, texture[0]); 1154 ctx.glBindTexture(GL_TEXTURE_BUFFER, texture[1]); 1155 ctx.expectError(GL_NO_ERROR); 1156 1157 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 1158 ctx.glFramebufferTexture(-1, GL_COLOR_ATTACHMENT0, texture[0], 0); 1159 ctx.expectError(GL_INVALID_ENUM); 1160 ctx.endSection(); 1161 1162 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens."); 1163 ctx.glFramebufferTexture(GL_FRAMEBUFFER, -1, texture[0], 0); 1164 ctx.expectError(GL_INVALID_ENUM); 1165 ctx.endSection(); 1166 1167 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object."); 1168 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0); 1169 ctx.expectError(GL_INVALID_VALUE); 1170 ctx.endSection(); 1171 1172 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target."); 1173 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1174 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0); 1175 ctx.expectError(GL_INVALID_OPERATION); 1176 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1177 ctx.endSection(); 1178 1179 ctx.beginSection("GL_INVALID_OPERATION is generated by if texture is a buffer texture."); 1180 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture[1], 0); 1181 ctx.expectError(GL_INVALID_OPERATION); 1182 ctx.endSection(); 1183 1184 ctx.glDeleteFramebuffers(1, &fbo); 1185 ctx.glDeleteBuffers(2, texture); 1186 } 1187} 1188 1189void framebuffer_texture2d (NegativeTestContext& ctx) 1190{ 1191 GLuint fbo = 0x1234; 1192 GLuint tex2D = 0x1234; 1193 GLuint texCube = 0x1234; 1194 GLuint tex2DMS = 0x1234; 1195 GLint maxTexSize = 0x1234; 1196 GLint maxTexCubeSize = 0x1234; 1197 int maxSize = 0x1234; 1198 1199 ctx.glGenFramebuffers(1, &fbo); 1200 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1201 ctx.glGenTextures(1, &tex2D); 1202 ctx.glBindTexture(GL_TEXTURE_2D, tex2D); 1203 ctx.glGenTextures(1, &texCube); 1204 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texCube); 1205 ctx.glGenTextures(1, &tex2DMS); 1206 ctx.glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, tex2DMS); 1207 ctx.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize); 1208 ctx.glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxTexCubeSize); 1209 ctx.expectError(GL_NO_ERROR); 1210 1211 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 1212 ctx.glFramebufferTexture2D(-1, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); 1213 ctx.expectError(GL_INVALID_ENUM); 1214 ctx.endSection(); 1215 1216 ctx.beginSection("GL_INVALID_ENUM is generated if textarget is not an accepted texture target."); 1217 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, tex2D, 0); 1218 ctx.expectError(GL_INVALID_ENUM); 1219 ctx.endSection(); 1220 1221 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not an accepted token."); 1222 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, -1, GL_TEXTURE_2D, tex2D, 0); 1223 ctx.expectError(GL_INVALID_ENUM); 1224 ctx.endSection(); 1225 1226 ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0 or larger than log_2 of maximum texture size."); 1227 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1); 1228 ctx.expectError(GL_INVALID_VALUE); 1229 maxSize = deLog2Floor32(maxTexSize) + 1; 1230 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxSize); 1231 ctx.expectError(GL_INVALID_VALUE); 1232 maxSize = deLog2Floor32(maxTexSize) + 1; 1233 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texCube, maxSize); 1234 ctx.expectError(GL_INVALID_VALUE); 1235 ctx.endSection(); 1236 1237 ctx.beginSection("GL_INVALID_VALUE is generated if level is larger than maximum texture size."); 1238 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxTexSize + 1); 1239 ctx.expectError(GL_INVALID_VALUE); 1240 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1); 1241 ctx.expectError(GL_INVALID_VALUE); 1242 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, texCube, maxTexCubeSize + 1); 1243 ctx.expectError(GL_INVALID_VALUE); 1244 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, texCube, -1); 1245 ctx.expectError(GL_INVALID_VALUE); 1246 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex2DMS, 1); 1247 ctx.expectError(GL_INVALID_VALUE); 1248 ctx.endSection(); 1249 1250 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object."); 1251 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, -1, 0); 1252 ctx.expectError(GL_INVALID_OPERATION); 1253 ctx.endSection(); 1254 1255 ctx.beginSection("GL_INVALID_OPERATION is generated if textarget and texture are not compatible."); 1256 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, tex2D, 0); 1257 ctx.expectError(GL_INVALID_OPERATION); 1258 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex2D, 0); 1259 ctx.expectError(GL_INVALID_OPERATION); 1260 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texCube, 0); 1261 ctx.expectError(GL_INVALID_OPERATION); 1262 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2DMS, 0); 1263 ctx.expectError(GL_INVALID_OPERATION); 1264 ctx.glDeleteTextures(1, &tex2D); 1265 ctx.glDeleteTextures(1, &texCube); 1266 ctx.glDeleteTextures(1, &tex2DMS); 1267 ctx.endSection(); 1268 1269 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target."); 1270 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0); 1271 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); 1272 ctx.expectError(GL_INVALID_OPERATION); 1273 ctx.endSection(); 1274 1275 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1276 { 1277 GLuint texBuf = 0x1234; 1278 ctx.beginSection("GL_INVALID_OPERATION error is generated if texture is the name of a buffer texture."); 1279 ctx.glGenTextures(1, &texBuf); 1280 ctx.glBindTexture(GL_TEXTURE_BUFFER, texBuf); 1281 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 1282 ctx.expectError(GL_NO_ERROR); 1283 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texBuf, 0); 1284 ctx.expectError(GL_INVALID_OPERATION); 1285 ctx.endSection(); 1286 } 1287 1288 ctx.glDeleteFramebuffers(1, &fbo); 1289} 1290 1291void renderbuffer_storage (NegativeTestContext& ctx) 1292{ 1293 deUint32 rbo = 0x1234; 1294 GLint maxSize = 0x1234; 1295 1296 ctx.glGenRenderbuffers (1, &rbo); 1297 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo); 1298 1299 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 1300 ctx.glRenderbufferStorage (-1, GL_RGBA4, 1, 1); 1301 ctx.expectError (GL_INVALID_ENUM); 1302 ctx.glRenderbufferStorage (GL_FRAMEBUFFER, GL_RGBA4, 1, 1); 1303 ctx.expectError (GL_INVALID_ENUM); 1304 ctx.endSection(); 1305 1306 ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format."); 1307 ctx.glRenderbufferStorage (GL_RENDERBUFFER, -1, 1, 1); 1308 ctx.expectError (GL_INVALID_ENUM); 1309 1310 if (!ctx.isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error 1311 { 1312 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGB16F, 1, 1); 1313 ctx.expectError (GL_INVALID_ENUM); 1314 } 1315 1316 if (!ctx.isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error 1317 { 1318 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1); 1319 ctx.expectError (GL_INVALID_ENUM); 1320 } 1321 1322 ctx.endSection(); 1323 1324 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than zero."); 1325 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, 1); 1326 ctx.expectError (GL_INVALID_VALUE); 1327 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, -1); 1328 ctx.expectError (GL_INVALID_VALUE); 1329 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, -1); 1330 ctx.expectError (GL_INVALID_VALUE); 1331 ctx.endSection(); 1332 1333 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE."); 1334 ctx.glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize); 1335 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, maxSize+1); 1336 ctx.expectError (GL_INVALID_VALUE); 1337 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, 1); 1338 ctx.expectError (GL_INVALID_VALUE); 1339 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, maxSize+1); 1340 ctx.expectError (GL_INVALID_VALUE); 1341 ctx.endSection(); 1342 1343 ctx.glDeleteRenderbuffers(1, &rbo); 1344} 1345 1346void blit_framebuffer (NegativeTestContext& ctx) 1347{ 1348 deUint32 fbo[2]; 1349 deUint32 rbo[2]; 1350 deUint32 texture[2]; 1351 deUint32 blankFrameBuffer; 1352 1353 ctx.glGenFramebuffers (1, &blankFrameBuffer); 1354 ctx.glGenFramebuffers (2, fbo); 1355 ctx.glGenTextures (2, texture); 1356 ctx.glGenRenderbuffers (2, rbo); 1357 1358 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]); 1359 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1360 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]); 1361 1362 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1363 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); 1364 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1365 ctx.glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]); 1366 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); 1367 1368 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]); 1369 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]); 1370 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1371 1372 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1373 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); 1374 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1375 ctx.glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[1]); 1376 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); 1377 ctx.expectError (GL_NO_ERROR); 1378 1379 ctx.beginSection("GL_INVALID_VALUE is generated if mask contains any bits other than GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, or GL_STENCIL_BUFFER_BIT."); 1380 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 1, GL_NEAREST); 1381 ctx.expectError (GL_INVALID_VALUE); 1382 ctx.endSection(); 1383 1384 ctx.beginSection("GL_INVALID_ENUM is generated if filter is not GL_LINEAR or GL_NEAREST."); 1385 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, 0); 1386 ctx.expectError (GL_INVALID_ENUM); 1387 ctx.endSection(); 1388 1389 ctx.beginSection("GL_INVALID_OPERATION is generated if mask contains any of the GL_DEPTH_BUFFER_BIT or GL_STENCIL_BUFFER_BIT and filter is not GL_NEAREST."); 1390 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR); 1391 ctx.expectError (GL_INVALID_OPERATION); 1392 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_LINEAR); 1393 ctx.expectError (GL_INVALID_OPERATION); 1394 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR); 1395 ctx.expectError (GL_INVALID_OPERATION); 1396 ctx.endSection(); 1397 1398 ctx.beginSection("GL_INVALID_OPERATION is generated if mask contains GL_COLOR_BUFFER_BIT and read buffer format is incompatible with draw buffer format."); 1399 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]); 1400 1401 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 1402 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1403 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32UI, draw buffer: GL_RGBA" << TestLog::EndMessage; 1404 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1405 ctx.expectError (GL_INVALID_OPERATION); 1406 1407 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 1408 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1409 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA" << TestLog::EndMessage; 1410 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1411 ctx.expectError (GL_INVALID_OPERATION); 1412 1413 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1414 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1415 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]); 1416 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 1417 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1418 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA8, draw buffer: GL_RGBA32I" << TestLog::EndMessage; 1419 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1420 ctx.expectError (GL_INVALID_OPERATION); 1421 ctx.endSection(); 1422 1423 ctx.beginSection("GL_INVALID_OPERATION is generated if filter is GL_LINEAR and the read buffer contains integer data."); 1424 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]); 1425 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 1426 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1427 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1428 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1429 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA8" << TestLog::EndMessage; 1430 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_LINEAR); 1431 ctx.expectError (GL_INVALID_OPERATION); 1432 ctx.endSection(); 1433 1434 ctx.beginSection("GL_INVALID_OPERATION is generated if mask contains GL_DEPTH_BUFFER_BIT or GL_STENCIL_BUFFER_BIT and the source and destination depth and stencil formats do not match."); 1435 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1436 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH32F_STENCIL8, 32, 32); 1437 ctx.glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]); 1438 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST); 1439 ctx.expectError (GL_INVALID_OPERATION); 1440 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_STENCIL_BUFFER_BIT, GL_NEAREST); 1441 ctx.expectError (GL_INVALID_OPERATION); 1442 ctx.endSection(); 1443 1444 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the read or draw framebuffer is not framebuffer complete."); 1445 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); 1446 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); 1447 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST); 1448 ctx.expectError (GL_NO_ERROR); 1449 ctx.getLog() << TestLog::Message << "// incomplete read framebuffer" << TestLog::EndMessage; 1450 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, blankFrameBuffer); 1451 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1452 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE); 1453 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); 1454 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST); 1455 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION); 1456 ctx.getLog() << TestLog::Message << "// incomplete draw framebuffer" << TestLog::EndMessage; 1457 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[1]); 1458 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, blankFrameBuffer); 1459 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); 1460 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE); 1461 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST); 1462 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION); 1463 ctx.getLog() << TestLog::Message << "// incomplete read and draw framebuffer" << TestLog::EndMessage; 1464 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, blankFrameBuffer); 1465 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, blankFrameBuffer); 1466 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE); 1467 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE); 1468 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST); 1469 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION); 1470 // restore 1471 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]); 1472 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); 1473 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1474 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); 1475 ctx.endSection(); 1476 1477 ctx.beginSection("GL_INVALID_OPERATION is generated if the source and destination buffers are identical."); 1478 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[0]); 1479 ctx.expectError (GL_NO_ERROR); 1480 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST); 1481 ctx.expectError (GL_INVALID_OPERATION); 1482 // restore 1483 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1484 ctx.endSection(); 1485 1486 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1487 ctx.glBindRenderbuffer (GL_RENDERBUFFER, 0); 1488 ctx.glDeleteFramebuffers (2, fbo); 1489 ctx.glDeleteFramebuffers (1, &blankFrameBuffer); 1490 ctx.glDeleteTextures (2, texture); 1491 ctx.glDeleteRenderbuffers (2, rbo); 1492} 1493 1494void blit_framebuffer_multisample (NegativeTestContext& ctx) 1495{ 1496 deUint32 fbo[2]; 1497 deUint32 rbo[2]; 1498 1499 ctx.glGenFramebuffers (2, fbo); 1500 ctx.glGenRenderbuffers (2, rbo); 1501 1502 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1503 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]); 1504 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 1505 ctx.glFramebufferRenderbuffer (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[0]); 1506 ctx.glCheckFramebufferStatus (GL_READ_FRAMEBUFFER); 1507 1508 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]); 1509 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1510 1511 ctx.expectError (GL_NO_ERROR); 1512 1513 if (!ctx.isExtensionSupported("GL_NV_framebuffer_multisample")) 1514 { 1515 ctx.beginSection("GL_INVALID_OPERATION is generated if the value of GL_SAMPLE_BUFFERS for the draw buffer is greater than zero."); 1516 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 1517 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1518 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1519 ctx.expectError (GL_INVALID_OPERATION); 1520 ctx.endSection(); 1521 1522 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_SAMPLE_BUFFERS for the read buffer is greater than zero and the formats of draw and read buffers are not identical."); 1523 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 32, 32); 1524 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1525 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1526 ctx.expectError (GL_INVALID_OPERATION); 1527 ctx.endSection(); 1528 1529 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_SAMPLE_BUFFERS for the read buffer is greater than zero and the source and destination rectangles are not defined with the same (X0, Y0) and (X1, Y1) bounds."); 1530 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32); 1531 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1532 ctx.glBlitFramebuffer (0, 0, 16, 16, 2, 2, 18, 18, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1533 ctx.expectError (GL_INVALID_OPERATION); 1534 ctx.endSection(); 1535 } 1536 1537 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1538 ctx.glDeleteRenderbuffers (2, rbo); 1539 ctx.glDeleteFramebuffers (2, fbo); 1540} 1541 1542void framebuffer_texture_layer (NegativeTestContext& ctx) 1543{ 1544 deUint32 fbo = 0x1234; 1545 deUint32 tex3D = 0x1234; 1546 deUint32 tex2DArray = 0x1234; 1547 deUint32 tex2D = 0x1234; 1548 deUint32 tex2DMSArray = 0x1234; 1549 deUint32 texBuffer = 0x1234; 1550 int max3DTexSize = 0x1234; 1551 int maxTexSize = 0x1234; 1552 int maxArrayTexLayers = 0x1234; 1553 int log2Max3DTexSize = 0x1234; 1554 int log2MaxTexSize = 0x1234; 1555 1556 ctx.glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE, &max3DTexSize); 1557 ctx.glGetIntegerv (GL_MAX_TEXTURE_SIZE, &maxTexSize); 1558 ctx.glGetIntegerv (GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTexLayers); 1559 1560 ctx.glGenFramebuffers (1, &fbo); 1561 ctx.glGenTextures (1, &tex3D); 1562 ctx.glGenTextures (1, &tex2DArray); 1563 ctx.glGenTextures (1, &tex2D); 1564 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1565 1566 ctx.glBindTexture (GL_TEXTURE_3D, tex3D); 1567 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1568 ctx.glBindTexture (GL_TEXTURE_2D_ARRAY, tex2DArray); 1569 ctx.glTexImage3D (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1570 ctx.glBindTexture (GL_TEXTURE_2D, tex2D); 1571 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1572 1573 ctx.expectError (GL_NO_ERROR); 1574 1575 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 1576 ctx.glFramebufferTextureLayer (-1, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1577 ctx.expectError (GL_INVALID_ENUM); 1578 ctx.glFramebufferTextureLayer (GL_RENDERBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1579 ctx.expectError (GL_INVALID_ENUM); 1580 ctx.endSection(); 1581 1582 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens."); 1583 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, -1, tex3D, 0, 1); 1584 ctx.expectError (GL_INVALID_ENUM); 1585 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_BACK, tex3D, 0, 1); 1586 ctx.expectError (GL_INVALID_ENUM); 1587 ctx.endSection(); 1588 1589 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is non-zero and not the name of a 3D texture or 2D array texture, 2D multisample array texture or cube map array texture."); 1590 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0, 0); 1591 ctx.expectError (GL_INVALID_OPERATION); 1592 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2D, 0, 0); 1593 ctx.expectError (GL_INVALID_OPERATION); 1594 ctx.endSection(); 1595 1596 ctx.beginSection("GL_INVALID_VALUE is generated if texture is not zero and layer is negative."); 1597 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, -1); 1598 ctx.expectError (GL_INVALID_VALUE); 1599 ctx.endSection(); 1600 1601 ctx.beginSection("GL_INVALID_VALUE is generated if texture is not zero and layer is greater than GL_MAX_3D_TEXTURE_SIZE-1 for a 3D texture."); 1602 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, max3DTexSize); 1603 ctx.expectError (GL_INVALID_VALUE); 1604 ctx.endSection(); 1605 1606 ctx.beginSection("GL_INVALID_VALUE is generated if texture is not zero and layer is greater than GL_MAX_ARRAY_TEXTURE_LAYERS-1 for a 2D array texture."); 1607 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, 0, maxArrayTexLayers); 1608 ctx.expectError (GL_INVALID_VALUE); 1609 ctx.endSection(); 1610 1611 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target."); 1612 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1613 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1614 ctx.expectError (GL_INVALID_OPERATION); 1615 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1616 ctx.endSection(); 1617 1618 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 3D texture and level is less than 0 or greater than log2 of the value of GL_MAX_3D_TEXTURE_SIZE."); 1619 log2Max3DTexSize = deLog2Floor32(max3DTexSize); 1620 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, -1, max3DTexSize - 1); 1621 ctx.expectError (GL_INVALID_VALUE); 1622 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, log2Max3DTexSize + 1, max3DTexSize - 1); 1623 ctx.expectError (GL_INVALID_VALUE); 1624 ctx.endSection(); 1625 1626 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 2D array texture and level is less than 0 or greater than log2 of the value of GL_MAX_TEXTURE_SIZE."); 1627 log2MaxTexSize = deLog2Floor32(maxTexSize); 1628 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, -1, maxArrayTexLayers - 1); 1629 ctx.expectError (GL_INVALID_VALUE); 1630 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, log2MaxTexSize + 1, maxArrayTexLayers - 1); 1631 ctx.expectError (GL_INVALID_VALUE); 1632 ctx.endSection(); 1633 1634 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1635 { 1636 deUint32 texCubeArray = 0x1234; 1637 int maxCubeTexSize = 0x1234; 1638 ctx.glGetIntegerv (GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxCubeTexSize); 1639 ctx.glGenTextures (1, &tex2DMSArray); 1640 ctx.glGenTextures (1, &texCubeArray); 1641 ctx.glGenTextures (1, &texBuffer); 1642 ctx.glBindTexture (GL_TEXTURE_2D_MULTISAMPLE_ARRAY, tex2DMSArray); 1643 ctx.glBindTexture (GL_TEXTURE_CUBE_MAP_ARRAY, texCubeArray); 1644 ctx.glBindTexture (GL_TEXTURE_BUFFER, texBuffer); 1645 ctx.expectError (GL_NO_ERROR); 1646 1647 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 2D multisample array texture and level is not 0."); 1648 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DMSArray, -1, 0); 1649 ctx.expectError (GL_INVALID_VALUE); 1650 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DMSArray, 1, 0); 1651 ctx.expectError (GL_INVALID_VALUE); 1652 ctx.endSection(); 1653 1654 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a cube map array texture and layer is larger than MAX_ARRAY_TEXTURE_LAYERS-1. (See Khronos bug 15968)"); 1655 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texCubeArray, 0, maxArrayTexLayers); 1656 ctx.expectError (GL_INVALID_VALUE); 1657 ctx.endSection(); 1658 1659 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is the name of a buffer texture."); 1660 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texBuffer, 0, 0); 1661 ctx.expectError (GL_INVALID_OPERATION); 1662 ctx.endSection(); 1663 1664 ctx.glDeleteTextures (1, &tex2DMSArray); 1665 ctx.glDeleteTextures (1, &texCubeArray); 1666 ctx.glDeleteTextures (1, &texBuffer); 1667 } 1668 1669 ctx.glDeleteTextures (1, &tex3D); 1670 ctx.glDeleteTextures (1, &tex2DArray); 1671 ctx.glDeleteTextures (1, &tex2D); 1672 ctx.glDeleteFramebuffers (1, &fbo); 1673} 1674 1675void invalidate_framebuffer (NegativeTestContext& ctx) 1676{ 1677 deUint32 attachments[3]; 1678 deUint32 fbo = 0x1234; 1679 deUint32 texture = 0x1234; 1680 int maxColorAttachments = 0x1234; 1681 1682 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 1683 attachments[0] = GL_COLOR_ATTACHMENT0; 1684 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments; 1685 attachments[2] = GL_DEPTH_STENCIL_ATTACHMENT; 1686 1687 ctx.glGenFramebuffers (1, &fbo); 1688 ctx.glGenTextures (1, &texture); 1689 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1690 ctx.glBindTexture (GL_TEXTURE_2D, texture); 1691 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1692 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 1693 ctx.glCheckFramebufferStatus (GL_FRAMEBUFFER); 1694 ctx.expectError (GL_NO_ERROR); 1695 1696 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER."); 1697 ctx.glInvalidateFramebuffer (-1, 1, &attachments[0]); 1698 ctx.expectError (GL_INVALID_ENUM); 1699 ctx.glInvalidateFramebuffer (GL_BACK, 1, &attachments[0]); 1700 ctx.expectError (GL_INVALID_ENUM); 1701 ctx.endSection(); 1702 1703 ctx.beginSection("GL_INVALID_OPERATION is generated if attachments contains GL_COLOR_ATTACHMENTm and m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS."); 1704 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1]); 1705 ctx.expectError (GL_INVALID_OPERATION); 1706 ctx.endSection(); 1707 1708 ctx.beginSection("GL_INVALID_VALUE is generated if numAttachments is negative."); 1709 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0]); 1710 ctx.expectError (GL_INVALID_VALUE); 1711 ctx.endSection(); 1712 1713 ctx.beginSection("GL_INVALID_ENUM is generated if the default framebuffer is bound to target and any elements of attachments are not one of the accepted attachments."); 1714 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1715 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[2]); 1716 ctx.expectError (GL_INVALID_ENUM); 1717 ctx.endSection(); 1718 1719 1720 ctx.glDeleteTextures (1, &texture); 1721 ctx.glDeleteFramebuffers (1, &fbo); 1722} 1723 1724void invalidate_sub_framebuffer (NegativeTestContext& ctx) 1725{ 1726 deUint32 attachments[3]; 1727 deUint32 fbo = 0x1234; 1728 deUint32 texture = 0x1234; 1729 int maxColorAttachments = 0x1234; 1730 1731 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 1732 attachments[0] = GL_COLOR_ATTACHMENT0; 1733 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments; 1734 attachments[2] = GL_DEPTH_STENCIL_ATTACHMENT; 1735 1736 ctx.glGenFramebuffers (1, &fbo); 1737 ctx.glGenTextures (1, &texture); 1738 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1739 ctx.glBindTexture (GL_TEXTURE_2D, texture); 1740 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1741 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 1742 ctx.glCheckFramebufferStatus (GL_FRAMEBUFFER); 1743 ctx.expectError (GL_NO_ERROR); 1744 1745 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER."); 1746 ctx.glInvalidateSubFramebuffer (-1, 1, &attachments[0], 0, 0, 16, 16); 1747 ctx.expectError (GL_INVALID_ENUM); 1748 ctx.glInvalidateSubFramebuffer (GL_BACK, 1, &attachments[0], 0, 0, 16, 16); 1749 ctx.expectError (GL_INVALID_ENUM); 1750 ctx.endSection(); 1751 1752 ctx.beginSection("GL_INVALID_OPERATION is generated if attachments contains GL_COLOR_ATTACHMENTm and m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS."); 1753 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1], 0, 0, 16, 16); 1754 ctx.expectError (GL_INVALID_OPERATION); 1755 ctx.endSection(); 1756 1757 ctx.beginSection("GL_INVALID_VALUE is generated if numAttachments, width, or heigh is negative."); 1758 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, 16, 16); 1759 ctx.expectError (GL_INVALID_VALUE); 1760 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, -1, 16); 1761 ctx.expectError (GL_INVALID_VALUE); 1762 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, 16, -1); 1763 ctx.expectError (GL_INVALID_VALUE); 1764 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, -1, -1); 1765 ctx.expectError (GL_INVALID_VALUE); 1766 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, -1, 16); 1767 ctx.expectError (GL_INVALID_VALUE); 1768 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, 16, -1); 1769 ctx.expectError (GL_INVALID_VALUE); 1770 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, -1, -1); 1771 ctx.expectError (GL_INVALID_VALUE); 1772 ctx.endSection(); 1773 1774 ctx.beginSection("GL_INVALID_ENUM is generated if the default framebuffer is bound to target and any elements of attachments are not one of the accepted attachments."); 1775 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0); 1776 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[2], 0, 0, 16, 16); 1777 ctx.expectError (GL_INVALID_ENUM); 1778 ctx.endSection(); 1779 1780 ctx.glDeleteTextures (1, &texture); 1781 ctx.glDeleteFramebuffers (1, &fbo); 1782} 1783 1784void renderbuffer_storage_multisample (NegativeTestContext& ctx) 1785{ 1786 deUint32 rbo = 0x1234; 1787 int maxSamplesSupportedRGBA4 = -1; 1788 int maxSamplesSupportedRGBA8UI = -1; 1789 GLint maxSize = 0x1234; 1790 1791 ctx.glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, 1, &maxSamplesSupportedRGBA4); 1792 ctx.glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA8UI, GL_SAMPLES, 1, &maxSamplesSupportedRGBA8UI); 1793 1794 ctx.glGenRenderbuffers (1, &rbo); 1795 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo); 1796 1797 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 1798 ctx.glRenderbufferStorageMultisample (-1, 2, GL_RGBA4, 1, 1); 1799 ctx.expectError (GL_INVALID_ENUM); 1800 ctx.glRenderbufferStorageMultisample (GL_FRAMEBUFFER, 2, GL_RGBA4, 1, 1); 1801 ctx.expectError (GL_INVALID_ENUM); 1802 ctx.endSection(); 1803 1804 ctx.beginSection("GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat."); 1805 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA4+1, GL_RGBA4, 1, 1); 1806 ctx.expectError (GL_INVALID_OPERATION); 1807 ctx.endSection(); 1808 1809 ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format."); 1810 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, -1, 1, 1); 1811 ctx.expectError (GL_INVALID_ENUM); 1812 1813 if (!ctx.isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error 1814 { 1815 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1); 1816 ctx.expectError (GL_INVALID_ENUM); 1817 } 1818 1819 if (!ctx.isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error 1820 { 1821 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1); 1822 ctx.expectError (GL_INVALID_ENUM); 1823 } 1824 1825 ctx.endSection(); 1826 1827 ctx.beginSection("GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat. (Unsigned integer format)"); 1828 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA8UI+1, GL_RGBA8UI, 1, 1); 1829 ctx.expectError (GL_INVALID_OPERATION); 1830 ctx.endSection(); 1831 1832 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than zero."); 1833 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, 1); 1834 ctx.expectError (GL_INVALID_VALUE); 1835 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, 1, -1); 1836 ctx.expectError (GL_INVALID_VALUE); 1837 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, -1); 1838 ctx.expectError (GL_INVALID_VALUE); 1839 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, 1, 1); 1840 ctx.expectError (GL_INVALID_VALUE); 1841 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, -1, 1); 1842 ctx.expectError (GL_INVALID_VALUE); 1843 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, 1, -1); 1844 ctx.expectError (GL_INVALID_VALUE); 1845 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, -1, -1); 1846 ctx.expectError (GL_INVALID_VALUE); 1847 ctx.endSection(); 1848 1849 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE."); 1850 ctx.glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize); 1851 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, 1, maxSize+1); 1852 ctx.expectError (GL_INVALID_VALUE); 1853 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, 1); 1854 ctx.expectError (GL_INVALID_VALUE); 1855 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, maxSize+1); 1856 ctx.expectError (GL_INVALID_VALUE); 1857 ctx.endSection(); 1858 1859 ctx.glDeleteRenderbuffers(1, &rbo); 1860} 1861 1862void copy_image_sub_data (NegativeTestContext& ctx) 1863{ 1864 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1865 { 1866 deUint32 texture[5]; 1867 deUint32 rbo = 0x1234; 1868 1869 ctx.glGenTextures (5, texture); 1870 ctx.glGenRenderbuffers (1, &rbo); 1871 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo); 1872 1873 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]); 1874 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1875 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1876 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1877 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32); 1878 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]); 1879 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1880 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1881 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1882 ctx.expectError (GL_NO_ERROR); 1883 1884 ctx.glBindTexture (GL_TEXTURE_3D, texture[2]); 1885 ctx.glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1886 ctx.glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1887 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1888 ctx.expectError (GL_NO_ERROR); 1889 1890 ctx.glBindTexture (GL_TEXTURE_3D, texture[3]); 1891 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1892 ctx.expectError (GL_NO_ERROR); 1893 1894 ctx.glBindTexture (GL_TEXTURE_2D, texture[4]); 1895 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1896 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1897 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL); 1898 ctx.expectError (GL_NO_ERROR); 1899 1900 ctx.beginSection("GL_INVALID_VALUE is generated if srcWidth, srcHeight, or srcDepth is negative."); 1901 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, 1, 1); 1902 ctx.expectError (GL_INVALID_VALUE); 1903 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, -1, 1); 1904 ctx.expectError (GL_INVALID_VALUE); 1905 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, 1, -1); 1906 ctx.expectError (GL_INVALID_VALUE); 1907 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, -1, 1); 1908 ctx.expectError (GL_INVALID_VALUE); 1909 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, 1, -1); 1910 ctx.expectError (GL_INVALID_VALUE); 1911 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, -1, -1); 1912 ctx.expectError (GL_INVALID_VALUE); 1913 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, -1, -1); 1914 ctx.expectError (GL_INVALID_VALUE); 1915 ctx.endSection(); 1916 1917 ctx.beginSection("GL_INVALID_VALUE is generated if srcLevel and dstLevel are not valid levels for the corresponding images."); 1918 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1919 ctx.expectError (GL_INVALID_VALUE); 1920 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 1, 0, 0, 0, 0, 0, 1); 1921 ctx.expectError (GL_INVALID_VALUE); 1922 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 1, 0, 0, 0, 0, 0, 1); 1923 ctx.expectError (GL_INVALID_VALUE); 1924 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1925 ctx.expectError (GL_INVALID_VALUE); 1926 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, -1, 0, 0, 0, 0, 0, 1); 1927 ctx.expectError (GL_INVALID_VALUE); 1928 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, -1, 0, 0, 0, 0, 0, 1); 1929 ctx.expectError (GL_INVALID_VALUE); 1930 ctx.glCopyImageSubData (rbo, GL_RENDERBUFFER, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1931 ctx.expectError (GL_INVALID_VALUE); 1932 ctx.glCopyImageSubData (rbo, GL_RENDERBUFFER, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1933 ctx.expectError (GL_INVALID_VALUE); 1934 ctx.glCopyImageSubData (texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, rbo, GL_RENDERBUFFER, -1, 0, 0, 0, 0, 0, 1); 1935 ctx.expectError (GL_INVALID_VALUE); 1936 ctx.glCopyImageSubData (texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, rbo, GL_RENDERBUFFER, 1, 0, 0, 0, 0, 0, 1); 1937 ctx.expectError (GL_INVALID_VALUE); 1938 ctx.endSection(); 1939 1940 ctx.beginSection("GL_INVALID_ENUM is generated if either target does not match the type of the object."); 1941 // \note: This could be either: 1942 // 1. GL_INVALID_ENUM is generated if either target does not match the type of the object. 1943 // 2. GL_INVALID_VALUE is generated if either name does not correspond to a valid renderbuffer or texture object according to the corresponding target parameter. 1944 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1); 1945 ctx.expectError (GL_INVALID_ENUM); 1946 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[2], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1947 ctx.expectError (GL_INVALID_ENUM); 1948 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_3D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1949 ctx.expectError (GL_INVALID_ENUM); 1950 ctx.glCopyImageSubData (texture[2], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1951 ctx.expectError (GL_INVALID_ENUM); 1952 ctx.endSection(); 1953 1954 ctx.beginSection("GL_INVALID_OPERATION is generated if either object is a texture and the texture is not complete."); 1955 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1); 1956 ctx.expectError (GL_INVALID_OPERATION); 1957 ctx.glCopyImageSubData (texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1958 ctx.expectError (GL_INVALID_OPERATION); 1959 ctx.glCopyImageSubData (texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1); 1960 ctx.expectError (GL_INVALID_OPERATION); 1961 ctx.endSection(); 1962 1963 ctx.beginSection("GL_INVALID_VALUE is generated if the dimensions of either subregion exceeds the boundaries of the corresponding image object."); 1964 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 33, 0, 1); 1965 ctx.expectError (GL_INVALID_VALUE); 1966 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 33, 1); 1967 ctx.expectError (GL_INVALID_VALUE); 1968 ctx.endSection(); 1969 1970 ctx.beginSection("GL_INVALID_OPERATION error is generated if the source and destination internal formats are not compatible."); 1971 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[4], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1972 ctx.expectError (GL_INVALID_OPERATION); 1973 ctx.glCopyImageSubData (texture[4], GL_TEXTURE_2D, 0, 0, 0, 0, texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1); 1974 ctx.expectError (GL_INVALID_OPERATION); 1975 ctx.endSection(); 1976 1977 ctx.glDeleteTextures (5, texture); 1978 ctx.glDeleteRenderbuffers (1, &rbo); 1979 } 1980} 1981 1982std::vector<FunctionContainer> getNegativeBufferApiTestFunctions () 1983{ 1984 const FunctionContainer funcs[] = 1985 { 1986 {bind_buffer, "bind_buffer", "Invalid glBindBuffer() usage" }, 1987 {delete_buffers, "delete_buffers", "Invalid glDeleteBuffers() usage" }, 1988 {gen_buffers, "gen_buffers", "Invalid glGenBuffers() usage" }, 1989 {buffer_data, "buffer_data", "Invalid glBufferData() usage" }, 1990 {buffer_sub_data, "buffer_sub_data", "Invalid glBufferSubData() usage" }, 1991 {buffer_sub_data_size_offset, "buffer_sub_data_size_offset", "Invalid glBufferSubData() usage" }, 1992 {clear, "clear", "Invalid glClear() usage" }, 1993 {read_pixels, "read_pixels", "Invalid glReadPixels() usage" }, 1994 {readn_pixels, "readn_pixels", "Invalid glReadPixels() usage" }, 1995 {read_pixels_format_mismatch, "read_pixels_format_mismatch", "Invalid glReadPixels() usage" }, 1996 {read_pixels_fbo_format_mismatch, "read_pixels_fbo_format_mismatch", "Invalid glReadPixels() usage" }, 1997 {bind_buffer_range, "bind_buffer_range", "Invalid glBindBufferRange() usage" }, 1998 {bind_buffer_base, "bind_buffer_base", "Invalid glBindBufferBase() usage" }, 1999 {clear_bufferiv, "clear_bufferiv", "Invalid glClearBufferiv() usage" }, 2000 {clear_bufferuiv, "clear_bufferuiv", "Invalid glClearBufferuiv() usage" }, 2001 {clear_bufferfv, "clear_bufferfv", "Invalid glClearBufferfv() usage" }, 2002 {clear_bufferfi, "clear_bufferfi", "Invalid glClearBufferfi() usage" }, 2003 {copy_buffer_sub_data, "copy_buffer_sub_data", "Invalid glCopyBufferSubData() usage" }, 2004 {draw_buffers, "draw_buffers", "Invalid glDrawBuffers() usage" }, 2005 {flush_mapped_buffer_range, "flush_mapped_buffer_range", "Invalid glFlushMappedBufferRange() usage" }, 2006 {map_buffer_range, "map_buffer_range", "Invalid glMapBufferRange() usage" }, 2007 {read_buffer, "read_buffer", "Invalid glReadBuffer() usage" }, 2008 {unmap_buffer, "unmap_buffer", "Invalid glUnmapBuffer() usage" }, 2009 {bind_framebuffer, "bind_framebuffer", "Invalid glBindFramebuffer() usage" }, 2010 {bind_renderbuffer, "bind_renderbuffer", "Invalid glBindRenderbuffer() usage" }, 2011 {check_framebuffer_status, "check_framebuffer_status", "Invalid glCheckFramebufferStatus() usage" }, 2012 {gen_framebuffers, "gen_framebuffers", "Invalid glGenFramebuffers() usage" }, 2013 {gen_renderbuffers, "gen_renderbuffers", "Invalid glGenRenderbuffers() usage" }, 2014 {delete_framebuffers, "delete_framebuffers", "Invalid glDeleteFramebuffers() usage" }, 2015 {delete_renderbuffers, "delete_renderbuffers", "Invalid glDeleteRenderbuffers() usage" }, 2016 {framebuffer_renderbuffer, "framebuffer_renderbuffer", "Invalid glFramebufferRenderbuffer() usage" }, 2017 {framebuffer_texture, "framebuffer_texture", "Invalid glFramebufferTexture() usage" }, 2018 {framebuffer_texture2d, "framebuffer_texture2d", "Invalid glFramebufferTexture2D() usage" }, 2019 {renderbuffer_storage, "renderbuffer_storage", "Invalid glRenderbufferStorage() usage" }, 2020 {blit_framebuffer, "blit_framebuffer", "Invalid glBlitFramebuffer() usage" }, 2021 {blit_framebuffer_multisample, "blit_framebuffer_multisample", "Invalid glBlitFramebuffer() usage" }, 2022 {framebuffer_texture_layer, "framebuffer_texture_layer", "Invalid glFramebufferTextureLayer() usage" }, 2023 {invalidate_framebuffer, "invalidate_framebuffer", "Invalid glInvalidateFramebuffer() usage" }, 2024 {invalidate_sub_framebuffer, "invalidate_sub_framebuffer", "Invalid glInvalidateSubFramebuffer() usage" }, 2025 {renderbuffer_storage_multisample, "renderbuffer_storage_multisample", "Invalid glRenderbufferStorageMultisample() usage" }, 2026 {copy_image_sub_data, "copy_image_sub_data", "Invalid glCopyImageSubData() usage" }, 2027 }; 2028 2029 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 2030} 2031 2032} // NegativeTestShared 2033} // Functional 2034} // gles31 2035} // deqp 2036