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