1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Negative Buffer API tests. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es3fNegativeBufferApiTests.hpp" 25#include "es3fApiCase.hpp" 26#include "gluContextInfo.hpp" 27 28#include "glwDefs.hpp" 29#include "glwEnums.hpp" 30 31using namespace glw; // GL types 32 33namespace deqp 34{ 35namespace gles3 36{ 37namespace Functional 38{ 39 40using tcu::TestLog; 41 42NegativeBufferApiTests::NegativeBufferApiTests (Context& context) 43 : TestCaseGroup(context, "buffer", "Negative Buffer API Cases") 44{ 45} 46 47NegativeBufferApiTests::~NegativeBufferApiTests (void) 48{ 49} 50 51void NegativeBufferApiTests::init (void) 52{ 53 // Buffers 54 55 ES3F_ADD_API_CASE(bind_buffer, "Invalid glBindBuffer() usage", 56 { 57 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the allowable values."); 58 glBindBuffer(-1, 0); 59 expectError(GL_INVALID_ENUM); 60 m_log << TestLog::EndSection; 61 }); 62 ES3F_ADD_API_CASE(delete_buffers, "Invalid glDeleteBuffers() usage", 63 { 64 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 65 glDeleteBuffers(-1, 0); 66 expectError(GL_INVALID_VALUE); 67 m_log << TestLog::EndSection; 68 }); 69 ES3F_ADD_API_CASE(gen_buffers, "Invalid glGenBuffers() usage", 70 { 71 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 72 glGenBuffers(-1, 0); 73 expectError(GL_INVALID_VALUE); 74 m_log << TestLog::EndSection; 75 }); 76 ES3F_ADD_API_CASE(buffer_data, "Invalid glBufferData() usage", 77 { 78 GLuint buffer; 79 glGenBuffers(1, &buffer); 80 glBindBuffer(GL_ARRAY_BUFFER, buffer); 81 82 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER."); 83 glBufferData(-1, 0, NULL, GL_STREAM_DRAW); 84 expectError(GL_INVALID_ENUM); 85 m_log << TestLog::EndSection; 86 87 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if usage is not GL_STREAM_DRAW, GL_STATIC_DRAW, or GL_DYNAMIC_DRAW."); 88 glBufferData(GL_ARRAY_BUFFER, 0, NULL, -1); 89 expectError(GL_INVALID_ENUM); 90 m_log << TestLog::EndSection; 91 92 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if size is negative."); 93 glBufferData(GL_ARRAY_BUFFER, -1, NULL, GL_STREAM_DRAW); 94 expectError(GL_INVALID_VALUE); 95 m_log << TestLog::EndSection; 96 97 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target."); 98 glBindBuffer(GL_ARRAY_BUFFER, 0); 99 glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STREAM_DRAW); 100 expectError(GL_INVALID_OPERATION); 101 m_log << TestLog::EndSection; 102 103 glDeleteBuffers(1, &buffer); 104 }); 105 ES3F_ADD_API_CASE(buffer_sub_data, "Invalid glBufferSubData() usage", 106 { 107 GLuint buffer; 108 glGenBuffers(1, &buffer); 109 glBindBuffer(GL_ARRAY_BUFFER, buffer); 110 glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW); 111 112 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER."); 113 glBufferSubData(-1, 1, 1, 0); 114 expectError(GL_INVALID_ENUM); 115 m_log << TestLog::EndSection; 116 117 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target."); 118 glBindBuffer(GL_ARRAY_BUFFER, 0); 119 glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0); 120 expectError(GL_INVALID_OPERATION); 121 m_log << TestLog::EndSection; 122 123 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer object being updated is mapped."); 124 glBindBuffer(GL_ARRAY_BUFFER, buffer); 125 glMapBufferRange(GL_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT); 126 expectError(GL_NO_ERROR); 127 glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0); 128 expectError(GL_INVALID_OPERATION); 129 m_log << TestLog::EndSection; 130 131 glDeleteBuffers(1, &buffer); 132 }); 133 ES3F_ADD_API_CASE(buffer_sub_data_size_offset, "Invalid glBufferSubData() usage", 134 { 135 GLuint buffer; 136 glGenBuffers(1, &buffer); 137 glBindBuffer(GL_ARRAY_BUFFER, buffer); 138 glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW); 139 140 m_log << TestLog::Section("", "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."); 141 glBufferSubData(GL_ARRAY_BUFFER, -1, 1, 0); 142 expectError(GL_INVALID_VALUE); 143 glBufferSubData(GL_ARRAY_BUFFER, -1, -1, 0); 144 expectError(GL_INVALID_VALUE); 145 glBufferSubData(GL_ARRAY_BUFFER, 1, -1, 0); 146 expectError(GL_INVALID_VALUE); 147 glBufferSubData(GL_ARRAY_BUFFER, 15, 1, 0); 148 expectError(GL_INVALID_VALUE); 149 glBufferSubData(GL_ARRAY_BUFFER, 1, 15, 0); 150 expectError(GL_INVALID_VALUE); 151 glBufferSubData(GL_ARRAY_BUFFER, 8, 8, 0); 152 expectError(GL_INVALID_VALUE); 153 m_log << TestLog::EndSection; 154 155 glDeleteBuffers(1, &buffer); 156 }); 157 ES3F_ADD_API_CASE(clear, "Invalid glClear() usage", 158 { 159 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if any bit other than the three defined bits is set in mask."); 160 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); 161 expectError(GL_NO_ERROR); 162 glClear(0x00000200); 163 expectError(GL_INVALID_VALUE); 164 glClear(0x00001000); 165 expectError(GL_INVALID_VALUE); 166 glClear(0x00000010); 167 expectError(GL_INVALID_VALUE); 168 m_log << TestLog::EndSection; 169 }); 170 ES3F_ADD_API_CASE(read_pixels, "Invalid glReadPixels() usage", 171 { 172 std::vector<GLubyte> ubyteData(4); 173 174 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of format and type is unsupported."); 175 glReadPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ubyteData[0]); 176 expectError(GL_INVALID_OPERATION); 177 m_log << TestLog::EndSection; 178 179 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either width or height is negative."); 180 glReadPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 181 expectError(GL_INVALID_VALUE); 182 glReadPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 183 expectError(GL_INVALID_VALUE); 184 glReadPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 185 expectError(GL_INVALID_VALUE); 186 m_log << TestLog::EndSection; 187 188 m_log << TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete."); 189 GLuint fbo; 190 glGenFramebuffers(1, &fbo); 191 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 192 glCheckFramebufferStatus(GL_FRAMEBUFFER); 193 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 194 expectError(GL_INVALID_FRAMEBUFFER_OPERATION); 195 m_log << TestLog::EndSection; 196 197 glDeleteFramebuffers(1, &fbo); 198 }); 199 ES3F_ADD_API_CASE(read_pixels_format_mismatch, "Invalid glReadPixels() usage", 200 { 201 std::vector<GLubyte> ubyteData(4); 202 std::vector<GLushort> ushortData(4); 203 204 m_log << TestLog::Section("", "Unsupported combinations of format and type will generate an INVALID_OPERATION error."); 205 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]); 206 expectError(GL_INVALID_OPERATION); 207 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]); 208 expectError(GL_INVALID_OPERATION); 209 glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]); 210 expectError(GL_INVALID_OPERATION); 211 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]); 212 expectError(GL_INVALID_OPERATION); 213 glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]); 214 expectError(GL_INVALID_OPERATION); 215 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]); 216 expectError(GL_INVALID_OPERATION); 217 m_log << TestLog::EndSection; 218 219 m_log << TestLog::Section("", "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."); 220 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 221 expectError(GL_NO_ERROR); 222 GLint readFormat; 223 GLint readType; 224 glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat); 225 glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType); 226 glReadPixels(0, 0, 1, 1, readFormat, readType, &ubyteData[0]); 227 expectError(GL_NO_ERROR); 228 m_log << TestLog::EndSection; 229 }); 230 ES3F_ADD_API_CASE(read_pixels_fbo_format_mismatch, "Invalid glReadPixels() usage", 231 { 232 std::vector<GLubyte> ubyteData(4); 233 std::vector<float> floatData(4); 234 deUint32 fbo; 235 deUint32 texture; 236 237 glGenTextures (1, &texture); 238 glBindTexture (GL_TEXTURE_2D, texture); 239 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 240 glGenFramebuffers (1, &fbo); 241 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 242 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 243 expectError (GL_NO_ERROR); 244 245 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if currently bound framebuffer format is incompatible with format and type."); 246 247 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 248 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 249 glCheckFramebufferStatus(GL_FRAMEBUFFER); 250 expectError (GL_NO_ERROR); 251 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 252 expectError (GL_INVALID_OPERATION); 253 254 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 255 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 256 glCheckFramebufferStatus(GL_FRAMEBUFFER); 257 expectError (GL_NO_ERROR); 258 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 259 expectError (GL_INVALID_OPERATION); 260 261 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 262 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 263 glCheckFramebufferStatus(GL_FRAMEBUFFER); 264 expectError (GL_NO_ERROR); 265 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]); 266 expectError (GL_INVALID_OPERATION); 267 268 m_log << TestLog::EndSection; 269 270 m_log << TestLog::Section("", "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."); 271 272 int binding = -1; 273 int sampleBuffers; 274 deUint32 rbo; 275 276 glGenRenderbuffers(1, &rbo); 277 glBindRenderbuffer(GL_RENDERBUFFER, rbo); 278 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 279 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo); 280 281 glGetIntegerv (GL_READ_FRAMEBUFFER_BINDING, &binding); 282 m_log << TestLog::Message << "// GL_READ_FRAMEBUFFER_BINDING: " << binding << TestLog::EndMessage; 283 glCheckFramebufferStatus(GL_FRAMEBUFFER); 284 glGetIntegerv (GL_SAMPLE_BUFFERS, &sampleBuffers); 285 m_log << TestLog::Message << "// GL_SAMPLE_BUFFERS: " << sampleBuffers << TestLog::EndMessage; 286 expectError (GL_NO_ERROR); 287 288 if (binding == 0 || sampleBuffers <= 0) 289 { 290 m_log << TestLog::Message << "// ERROR: expected GL_READ_FRAMEBUFFER_BINDING to be non-zero and GL_SAMPLE_BUFFERS to be greater than zero" << TestLog::EndMessage; 291 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 292 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); 293 } 294 else 295 { 296 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]); 297 expectError (GL_INVALID_OPERATION); 298 } 299 300 m_log << TestLog::EndSection; 301 302 glBindRenderbuffer (GL_RENDERBUFFER, 0); 303 glBindTexture (GL_TEXTURE_2D, 0); 304 glBindFramebuffer (GL_FRAMEBUFFER, 0); 305 glDeleteFramebuffers (1, &fbo); 306 glDeleteTextures (1, &texture); 307 glDeleteRenderbuffers (1, &rbo); 308 }); 309 ES3F_ADD_API_CASE(bind_buffer_range, "Invalid glBindBufferRange() usage", 310 { 311 deUint32 bufU; 312 glGenBuffers(1, &bufU); 313 glBindBuffer(GL_UNIFORM_BUFFER, bufU); 314 glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW); 315 316 deUint32 bufTF; 317 glGenBuffers(1, &bufTF); 318 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF); 319 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW); 320 321 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER."); 322 glBindBufferRange(GL_ARRAY_BUFFER, 0, bufU, 0, 4); 323 expectError(GL_INVALID_ENUM); 324 m_log << TestLog::EndSection; 325 326 m_log << TestLog::Section("", "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."); 327 int maxTFSize; 328 glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize); 329 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF, 0, 4); 330 expectError(GL_INVALID_VALUE); 331 m_log << TestLog::EndSection; 332 333 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS."); 334 int maxUSize; 335 glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize); 336 glBindBufferRange(GL_UNIFORM_BUFFER, maxUSize, bufU, 0, 4); 337 expectError(GL_INVALID_VALUE); 338 m_log << TestLog::EndSection; 339 340 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if size is less than or equal to zero."); 341 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, -1); 342 expectError(GL_INVALID_VALUE); 343 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, 0); 344 expectError(GL_INVALID_VALUE); 345 m_log << TestLog::EndSection; 346 347 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and size or offset are not multiples of 4."); 348 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 4, 5); 349 expectError(GL_INVALID_VALUE); 350 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 4); 351 expectError(GL_INVALID_VALUE); 352 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 7); 353 expectError(GL_INVALID_VALUE); 354 m_log << TestLog::EndSection; 355 356 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and offset is not a multiple of GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT."); 357 int alignment; 358 glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &alignment); 359 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, alignment+1, 4); 360 expectError(GL_INVALID_VALUE); 361 m_log << TestLog::EndSection; 362 363 glDeleteBuffers(1, &bufU); 364 glDeleteBuffers(1, &bufTF); 365 }); 366 ES3F_ADD_API_CASE(bind_buffer_base, "Invalid glBindBufferBase() usage", 367 { 368 deUint32 bufU; 369 glGenBuffers(1, &bufU); 370 glBindBuffer(GL_UNIFORM_BUFFER, bufU); 371 glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW); 372 373 deUint32 bufTF; 374 glGenBuffers(1, &bufTF); 375 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF); 376 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW); 377 expectError(GL_NO_ERROR); 378 379 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER."); 380 glBindBufferBase(-1, 0, bufU); 381 expectError(GL_INVALID_ENUM); 382 glBindBufferBase(GL_ARRAY_BUFFER, 0, bufU); 383 expectError(GL_INVALID_ENUM); 384 m_log << TestLog::EndSection; 385 386 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS."); 387 int maxUSize; 388 glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize); 389 glBindBufferBase(GL_UNIFORM_BUFFER, maxUSize, bufU); 390 expectError(GL_INVALID_VALUE); 391 m_log << TestLog::EndSection; 392 393 m_log << TestLog::Section("", "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."); 394 int maxTFSize; 395 glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize); 396 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF); 397 expectError(GL_INVALID_VALUE); 398 m_log << TestLog::EndSection; 399 400 glDeleteBuffers(1, &bufU); 401 glDeleteBuffers(1, &bufTF); 402 }); 403 ES3F_ADD_API_CASE(clear_bufferiv, "Invalid glClearBufferiv() usage", 404 { 405 std::vector<int> data(32*32); 406 deUint32 fbo; 407 deUint32 texture; 408 409 glGenTextures (1, &texture); 410 glBindTexture (GL_TEXTURE_2D, texture); 411 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 412 glGenFramebuffers (1, &fbo); 413 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 414 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 415 glCheckFramebufferStatus(GL_FRAMEBUFFER); 416 expectError (GL_NO_ERROR); 417 418 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value."); 419 glClearBufferiv(-1, 0, &data[0]); 420 expectError(GL_INVALID_ENUM); 421 glClearBufferiv(GL_FRAMEBUFFER, 0, &data[0]); 422 expectError(GL_INVALID_ENUM); 423 m_log << TestLog::EndSection; 424 425 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 426 int maxDrawBuffers; 427 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 428 glClearBufferiv(GL_COLOR, maxDrawBuffers, &data[0]); 429 expectError(GL_INVALID_VALUE); 430 m_log << TestLog::EndSection; 431 432 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_DEPTH or GL_DEPTH_STENCIL."); 433 glClearBufferiv(GL_DEPTH, 1, &data[0]); 434 expectError(GL_INVALID_ENUM); 435 glClearBufferiv(GL_DEPTH_STENCIL, 1, &data[0]); 436 expectError(GL_INVALID_ENUM); 437 m_log << TestLog::EndSection; 438 439 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_STENCIL and drawBuffer is not zero."); 440 glClearBufferiv(GL_STENCIL, 1, &data[0]); 441 expectError(GL_INVALID_VALUE); 442 m_log << TestLog::EndSection; 443 444 glDeleteFramebuffers(1, &fbo); 445 glDeleteTextures(1, &texture); 446 }); 447 ES3F_ADD_API_CASE(clear_bufferuiv, "Invalid glClearBufferuiv() usage", 448 { 449 std::vector<deUint32> data(32*32); 450 deUint32 fbo; 451 deUint32 texture; 452 453 glGenTextures (1, &texture); 454 glBindTexture (GL_TEXTURE_2D, texture); 455 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 456 glGenFramebuffers (1, &fbo); 457 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 458 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 459 glCheckFramebufferStatus(GL_FRAMEBUFFER); 460 expectError (GL_NO_ERROR); 461 462 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value."); 463 glClearBufferuiv(-1, 0, &data[0]); 464 expectError(GL_INVALID_ENUM); 465 glClearBufferuiv(GL_FRAMEBUFFER, 0, &data[0]); 466 expectError(GL_INVALID_ENUM); 467 m_log << TestLog::EndSection; 468 469 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 470 int maxDrawBuffers; 471 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 472 glClearBufferuiv(GL_COLOR, maxDrawBuffers, &data[0]); 473 expectError(GL_INVALID_VALUE); 474 m_log << TestLog::EndSection; 475 476 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_DEPTH, GL_STENCIL or GL_DEPTH_STENCIL."); 477 glClearBufferuiv(GL_DEPTH, 1, &data[0]); 478 expectError(GL_INVALID_ENUM); 479 glClearBufferuiv(GL_STENCIL, 1, &data[0]); 480 expectError(GL_INVALID_ENUM); 481 glClearBufferuiv(GL_DEPTH_STENCIL, 1, &data[0]); 482 expectError(GL_INVALID_ENUM); 483 m_log << TestLog::EndSection; 484 485 glDeleteFramebuffers(1, &fbo); 486 glDeleteTextures(1, &texture); 487 }); 488 ES3F_ADD_API_CASE(clear_bufferfv, "Invalid glClearBufferfv() usage", 489 { 490 std::vector<float> data(32*32); 491 deUint32 fbo; 492 deUint32 texture; 493 494 glGenTextures (1, &texture); 495 glBindTexture (GL_TEXTURE_2D, texture); 496 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL); 497 glGenFramebuffers (1, &fbo); 498 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 499 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 500 glCheckFramebufferStatus(GL_FRAMEBUFFER); 501 expectError (GL_NO_ERROR); 502 503 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value."); 504 glClearBufferfv(-1, 0, &data[0]); 505 expectError(GL_INVALID_ENUM); 506 glClearBufferfv(GL_FRAMEBUFFER, 0, &data[0]); 507 expectError(GL_INVALID_ENUM); 508 m_log << TestLog::EndSection; 509 510 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS."); 511 int maxDrawBuffers; 512 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 513 glClearBufferfv(GL_COLOR, maxDrawBuffers, &data[0]); 514 expectError(GL_INVALID_VALUE); 515 m_log << TestLog::EndSection; 516 517 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_STENCIL or GL_DEPTH_STENCIL."); 518 glClearBufferfv(GL_STENCIL, 1, &data[0]); 519 expectError(GL_INVALID_ENUM); 520 glClearBufferfv(GL_DEPTH_STENCIL, 1, &data[0]); 521 expectError(GL_INVALID_ENUM); 522 m_log << TestLog::EndSection; 523 524 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_DEPTH and drawBuffer is not zero."); 525 glClearBufferfv(GL_DEPTH, 1, &data[0]); 526 expectError(GL_INVALID_VALUE); 527 m_log << TestLog::EndSection; 528 529 glDeleteFramebuffers(1, &fbo); 530 glDeleteTextures(1, &texture); 531 }); 532 ES3F_ADD_API_CASE(clear_bufferfi, "Invalid glClearBufferfi() usage", 533 { 534 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value."); 535 glClearBufferfi(-1, 0, 1.0f, 1); 536 expectError(GL_INVALID_ENUM); 537 glClearBufferfi(GL_FRAMEBUFFER, 0, 1.0f, 1); 538 expectError(GL_INVALID_ENUM); 539 m_log << TestLog::EndSection; 540 541 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not GL_DEPTH_STENCIL."); 542 glClearBufferfi(GL_DEPTH, 0, 1.0f, 1); 543 expectError(GL_INVALID_ENUM); 544 glClearBufferfi(GL_STENCIL, 0, 1.0f, 1); 545 expectError(GL_INVALID_ENUM); 546 glClearBufferfi(GL_COLOR, 0, 1.0f, 1); 547 expectError(GL_INVALID_ENUM); 548 m_log << TestLog::EndSection; 549 550 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_DEPTH_STENCIL and drawBuffer is not zero."); 551 glClearBufferfi(GL_DEPTH_STENCIL, 1, 1.0f, 1); 552 expectError(GL_INVALID_VALUE); 553 m_log << TestLog::EndSection; 554 }); 555 ES3F_ADD_API_CASE(copy_buffer_sub_data, "Invalid glCopyBufferSubData() usage", 556 { 557 deUint32 buf[2]; 558 std::vector<float> data(32*32); 559 560 glGenBuffers (2, buf); 561 glBindBuffer (GL_COPY_READ_BUFFER, buf[0]); 562 glBufferData (GL_COPY_READ_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 563 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 564 glBufferData (GL_COPY_WRITE_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 565 expectError (GL_NO_ERROR); 566 567 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if any of readoffset, writeoffset or size is negative."); 568 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, -4); 569 expectError (GL_INVALID_VALUE); 570 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, -1, 0, 4); 571 expectError (GL_INVALID_VALUE); 572 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, -1, 4); 573 expectError (GL_INVALID_VALUE); 574 m_log << TestLog::EndSection; 575 576 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if readoffset + size exceeds the size of the buffer object bound to readtarget."); 577 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36); 578 expectError (GL_INVALID_VALUE); 579 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 24, 0, 16); 580 expectError (GL_INVALID_VALUE); 581 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 36, 0, 4); 582 expectError (GL_INVALID_VALUE); 583 m_log << TestLog::EndSection; 584 585 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if writeoffset + size exceeds the size of the buffer object bound to writetarget."); 586 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36); 587 expectError (GL_INVALID_VALUE); 588 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 24, 16); 589 expectError (GL_INVALID_VALUE); 590 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 36, 4); 591 expectError (GL_INVALID_VALUE); 592 m_log << TestLog::EndSection; 593 594 m_log << TestLog::Section("", "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."); 595 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[0]); 596 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 4); 597 expectError (GL_NO_ERROR); 598 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 4); 599 expectError (GL_INVALID_VALUE); 600 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 18); 601 expectError (GL_INVALID_VALUE); 602 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 603 m_log << TestLog::EndSection; 604 605 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to readtarget or writetarget."); 606 glBindBuffer (GL_COPY_READ_BUFFER, 0); 607 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 608 expectError (GL_INVALID_OPERATION); 609 610 glBindBuffer (GL_COPY_READ_BUFFER, buf[0]); 611 glBindBuffer (GL_COPY_WRITE_BUFFER, 0); 612 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 613 expectError (GL_INVALID_OPERATION); 614 615 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]); 616 m_log << TestLog::EndSection; 617 618 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer object bound to either readtarget or writetarget is mapped."); 619 glMapBufferRange (GL_COPY_READ_BUFFER, 0, 4, GL_MAP_READ_BIT); 620 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 621 expectError (GL_INVALID_OPERATION); 622 glUnmapBuffer (GL_COPY_READ_BUFFER); 623 624 glMapBufferRange (GL_COPY_WRITE_BUFFER, 0, 4, GL_MAP_READ_BIT); 625 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16); 626 expectError (GL_INVALID_OPERATION); 627 glUnmapBuffer (GL_COPY_WRITE_BUFFER); 628 m_log << TestLog::EndSection; 629 630 glDeleteBuffers(2, buf); 631 }); 632 ES3F_ADD_API_CASE(draw_buffers, "Invalid glDrawBuffers() usage", 633 { 634 deUint32 fbo; 635 deUint32 texture; 636 int maxDrawBuffers; 637 glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 638 std::vector<deUint32> values(maxDrawBuffers+1); 639 values[0] = GL_NONE; 640 values[1] = GL_BACK; 641 values[2] = GL_COLOR_ATTACHMENT0; 642 values[3] = GL_DEPTH_ATTACHMENT; 643 std::vector<GLfloat> data(32*32); 644 645 glGenTextures (1, &texture); 646 glBindTexture (GL_TEXTURE_2D, texture); 647 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 648 glGenFramebuffers (1, &fbo); 649 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 650 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 651 glCheckFramebufferStatus(GL_FRAMEBUFFER); 652 expectError (GL_NO_ERROR); 653 654 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if one of the values in bufs is not an accepted value."); 655 glDrawBuffers (2, &values[2]); 656 expectError (GL_INVALID_ENUM); 657 m_log << TestLog::EndSection; 658 659 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and n is not 1."); 660 glBindFramebuffer (GL_FRAMEBUFFER, 0); 661 glDrawBuffers (2, &values[0]); 662 expectError (GL_INVALID_OPERATION); 663 m_log << TestLog::EndSection; 664 665 m_log << TestLog::Section("", "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."); 666 glBindFramebuffer (GL_FRAMEBUFFER, 0); 667 glDrawBuffers (1, &values[2]); 668 expectError (GL_INVALID_OPERATION); 669 m_log << TestLog::EndSection; 670 671 m_log << TestLog::Section("", "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."); 672 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 673 glDrawBuffers (1, &values[1]); 674 expectError (GL_INVALID_OPERATION); 675 m_log << TestLog::EndSection; 676 677 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is less than 0 or greater than GL_MAX_DRAW_BUFFERS."); 678 glDrawBuffers (-1, &values[1]); 679 expectError (GL_INVALID_VALUE); 680 glDrawBuffers (maxDrawBuffers+1, &values[0]); 681 expectError (GL_INVALID_VALUE); 682 m_log << TestLog::EndSection; 683 684 glDeleteTextures(1, &texture); 685 glDeleteFramebuffers(1, &fbo); 686 }); 687 ES3F_ADD_API_CASE(flush_mapped_buffer_range, "Invalid glFlushMappedBufferRange() usage", 688 { 689 deUint32 buf; 690 std::vector<GLfloat> data(32); 691 692 glGenBuffers (1, &buf); 693 glBindBuffer (GL_ARRAY_BUFFER, buf); 694 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_STATIC_READ); 695 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 696 expectError (GL_NO_ERROR); 697 698 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if offset or length is negative, or if offset + length exceeds the size of the mapping."); 699 glFlushMappedBufferRange(GL_ARRAY_BUFFER, -1, 1); 700 expectError (GL_INVALID_VALUE); 701 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, -1); 702 expectError (GL_INVALID_VALUE); 703 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 12, 8); 704 expectError (GL_INVALID_VALUE); 705 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 24, 4); 706 expectError (GL_INVALID_VALUE); 707 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 24); 708 expectError (GL_INVALID_VALUE); 709 m_log << TestLog::EndSection; 710 711 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target."); 712 glBindBuffer (GL_ARRAY_BUFFER, 0); 713 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 714 expectError (GL_INVALID_OPERATION); 715 m_log << TestLog::EndSection; 716 717 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer bound to target is not mapped, or is mapped without the GL_MAP_FLUSH_EXPLICIT flag."); 718 glBindBuffer (GL_ARRAY_BUFFER, buf); 719 glUnmapBuffer (GL_ARRAY_BUFFER); 720 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 721 expectError (GL_INVALID_OPERATION); 722 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT); 723 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8); 724 expectError (GL_INVALID_OPERATION); 725 m_log << TestLog::EndSection; 726 727 glUnmapBuffer (GL_ARRAY_BUFFER); 728 glDeleteBuffers (1, &buf); 729 }); 730 ES3F_ADD_API_CASE(map_buffer_range, "Invalid glMapBufferRange() usage", 731 { 732 deUint32 buf; 733 std::vector<GLfloat> data(32); 734 735 glGenBuffers (1, &buf); 736 glBindBuffer (GL_ARRAY_BUFFER, buf); 737 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 738 expectError (GL_NO_ERROR); 739 740 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either of offset or length is negative."); 741 glMapBufferRange (GL_ARRAY_BUFFER, -1, 1, GL_MAP_READ_BIT); 742 expectError (GL_INVALID_VALUE); 743 744 glMapBufferRange (GL_ARRAY_BUFFER, 1, -1, GL_MAP_READ_BIT); 745 expectError (GL_INVALID_VALUE); 746 m_log << TestLog::EndSection; 747 748 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if offset + length is greater than the value of GL_BUFFER_SIZE."); 749 glMapBufferRange (GL_ARRAY_BUFFER, 0, 33, GL_MAP_READ_BIT); 750 expectError (GL_INVALID_VALUE); 751 752 glMapBufferRange (GL_ARRAY_BUFFER, 32, 1, GL_MAP_READ_BIT); 753 expectError (GL_INVALID_VALUE); 754 755 glMapBufferRange (GL_ARRAY_BUFFER, 16, 17, GL_MAP_READ_BIT); 756 expectError (GL_INVALID_VALUE); 757 m_log << TestLog::EndSection; 758 759 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if access has any bits set other than those accepted."); 760 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | 0x1000); 761 expectError (GL_INVALID_VALUE); 762 763 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | 0x1000); 764 expectError (GL_INVALID_VALUE); 765 m_log << TestLog::EndSection; 766 767 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer is already in a mapped state."); 768 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT); 769 expectError (GL_NO_ERROR); 770 glMapBufferRange (GL_ARRAY_BUFFER, 16, 8, GL_MAP_READ_BIT); 771 expectError (GL_INVALID_OPERATION); 772 glUnmapBuffer (GL_ARRAY_BUFFER); 773 m_log << TestLog::EndSection; 774 775 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if neither GL_MAP_READ_BIT or GL_MAP_WRITE_BIT is set."); 776 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT); 777 expectError (GL_INVALID_OPERATION); 778 m_log << TestLog::EndSection; 779 780 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if "); 781 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT); 782 expectError (GL_INVALID_OPERATION); 783 m_log << TestLog::EndSection; 784 785 m_log << TestLog::Section("", "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."); 786 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT); 787 expectError (GL_INVALID_OPERATION); 788 789 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); 790 expectError (GL_INVALID_OPERATION); 791 792 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_UNSYNCHRONIZED_BIT); 793 expectError (GL_INVALID_OPERATION); 794 m_log << TestLog::EndSection; 795 796 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_MAP_FLUSH_EXPLICIT_BIT is set and GL_MAP_WRITE_BIT is not set."); 797 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 798 expectError (GL_INVALID_OPERATION); 799 m_log << TestLog::EndSection; 800 801 glDeleteBuffers (1, &buf); 802 }); 803 ES3F_ADD_API_CASE(read_buffer, "Invalid glReadBuffer() usage", 804 { 805 deUint32 fbo; 806 deUint32 texture; 807 int maxColorAttachments; 808 809 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 810 glGenTextures (1, &texture); 811 glBindTexture (GL_TEXTURE_2D, texture); 812 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 813 glGenFramebuffers (1, &fbo); 814 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 815 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 816 glCheckFramebufferStatus(GL_FRAMEBUFFER); 817 expectError (GL_NO_ERROR); 818 819 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if mode is not GL_BACK, GL_NONE, or GL_COLOR_ATTACHMENTi."); 820 glReadBuffer (GL_NONE); 821 expectError (GL_NO_ERROR); 822 glReadBuffer (1); 823 expectError (GL_INVALID_ENUM); 824 glReadBuffer (GL_FRAMEBUFFER); 825 expectError (GL_INVALID_ENUM); 826 glReadBuffer (GL_COLOR_ATTACHMENT0 - 1); 827 expectError (GL_INVALID_ENUM); 828 glReadBuffer (GL_FRONT); 829 expectError (GL_INVALID_ENUM); 830 831 // \ note Spec isn't actually clear here, but it is safe to assume that 832 // GL_DEPTH_ATTACHMENT can't be interpreted as GL_COLOR_ATTACHMENTm 833 // where m = (GL_DEPTH_ATTACHMENT - GL_COLOR_ATTACHMENT0). 834 glReadBuffer (GL_DEPTH_ATTACHMENT); 835 expectError (GL_INVALID_ENUM); 836 glReadBuffer (GL_STENCIL_ATTACHMENT); 837 expectError (GL_INVALID_ENUM); 838 glReadBuffer (GL_STENCIL_ATTACHMENT+1); 839 expectError (GL_INVALID_ENUM); 840 glReadBuffer (0xffffffffu); 841 expectError (GL_INVALID_ENUM); 842 m_log << TestLog::EndSection; 843 844 m_log << TestLog::Section("", "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."); 845 glReadBuffer (GL_BACK); 846 expectError (GL_INVALID_OPERATION); 847 glReadBuffer (GL_COLOR_ATTACHMENT0 + maxColorAttachments); 848 expectError (GL_INVALID_OPERATION); 849 850 if (GL_COLOR_ATTACHMENT0+maxColorAttachments < GL_DEPTH_ATTACHMENT-1) 851 { 852 glReadBuffer (GL_DEPTH_ATTACHMENT - 1); 853 expectError (GL_INVALID_OPERATION); 854 } 855 856 m_log << TestLog::EndSection; 857 858 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the current framebuffer is the default framebuffer and mode is not GL_NONE or GL_BACK."); 859 glBindFramebuffer (GL_FRAMEBUFFER, 0); 860 glReadBuffer (GL_COLOR_ATTACHMENT0); 861 expectError (GL_INVALID_OPERATION); 862 m_log << TestLog::EndSection; 863 864 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the current framebuffer is a named framebuffer and mode is not GL_NONE or GL_COLOR_ATTACHMENTi."); 865 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 866 glReadBuffer (GL_BACK); 867 expectError (GL_INVALID_OPERATION); 868 m_log << TestLog::EndSection; 869 870 glDeleteTextures(1, &texture); 871 glDeleteFramebuffers(1, &fbo); 872 }); 873 ES3F_ADD_API_CASE(unmap_buffer, "Invalid glUnmapBuffer() usage", 874 { 875 deUint32 buf; 876 std::vector<GLfloat> data(32); 877 878 glGenBuffers (1, &buf); 879 glBindBuffer (GL_ARRAY_BUFFER, buf); 880 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY); 881 expectError (GL_NO_ERROR); 882 883 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer data store is already in an unmapped state."); 884 glUnmapBuffer (GL_ARRAY_BUFFER); 885 expectError (GL_INVALID_OPERATION); 886 m_log << TestLog::EndSection; 887 888 glDeleteBuffers (1, &buf); 889 }); 890 // Framebuffer Objects 891 892 ES3F_ADD_API_CASE(bind_framebuffer, "Invalid glBindFramebuffer() usage", 893 { 894 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER."); 895 glBindFramebuffer(-1, 0); 896 expectError(GL_INVALID_ENUM); 897 glBindFramebuffer(GL_RENDERBUFFER, 0); 898 expectError(GL_INVALID_ENUM); 899 m_log << TestLog::EndSection; 900 }); 901 ES3F_ADD_API_CASE(bind_renderbuffer, "Invalid glBindRenderbuffer() usage", 902 { 903 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 904 glBindRenderbuffer(-1, 0); 905 expectError(GL_INVALID_ENUM); 906 glBindRenderbuffer(GL_FRAMEBUFFER, 0); 907 expectError(GL_INVALID_ENUM); 908 m_log << TestLog::EndSection; 909 }); 910 ES3F_ADD_API_CASE(check_framebuffer_status, "Invalid glCheckFramebufferStatus() usage", 911 { 912 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER."); 913 glCheckFramebufferStatus(-1); 914 expectError(GL_INVALID_ENUM); 915 glCheckFramebufferStatus(GL_RENDERBUFFER); 916 expectError(GL_INVALID_ENUM); 917 m_log << TestLog::EndSection; 918 }); 919 ES3F_ADD_API_CASE(gen_framebuffers, "Invalid glGenFramebuffers() usage", 920 { 921 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 922 glGenFramebuffers(-1, 0); 923 expectError(GL_INVALID_VALUE); 924 m_log << TestLog::EndSection; 925 }); 926 ES3F_ADD_API_CASE(gen_renderbuffers, "Invalid glGenRenderbuffers() usage", 927 { 928 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 929 glGenRenderbuffers(-1, 0); 930 expectError(GL_INVALID_VALUE); 931 m_log << TestLog::EndSection; 932 }); 933 ES3F_ADD_API_CASE(delete_framebuffers, "Invalid glDeleteFramebuffers() usage", 934 { 935 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 936 glDeleteFramebuffers(-1, 0); 937 expectError(GL_INVALID_VALUE); 938 m_log << TestLog::EndSection; 939 }); 940 ES3F_ADD_API_CASE(delete_renderbuffers, "Invalid glDeleteRenderbuffers() usage", 941 {; 942 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative."); 943 glDeleteRenderbuffers(-1, 0); 944 expectError(GL_INVALID_VALUE); 945 m_log << TestLog::EndSection; 946 }); 947 ES3F_ADD_API_CASE(framebuffer_renderbuffer, "Invalid glFramebufferRenderbuffer() usage", 948 { 949 GLuint fbo; 950 GLuint rbo; 951 glGenFramebuffers(1, &fbo); 952 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 953 glGenRenderbuffers(1, &rbo); 954 955 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 956 glFramebufferRenderbuffer(-1, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); 957 expectError(GL_INVALID_ENUM); 958 m_log << TestLog::EndSection; 959 960 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if renderbuffertarget is not GL_RENDERBUFFER."); 961 glBindRenderbuffer(GL_RENDERBUFFER, rbo); 962 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, rbo); 963 expectError(GL_INVALID_ENUM); 964 glBindRenderbuffer(GL_RENDERBUFFER, 0); 965 m_log << TestLog::EndSection; 966 967 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if renderbuffer is neither 0 nor the name of an existing renderbuffer object."); 968 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, -1); 969 expectError(GL_INVALID_OPERATION); 970 m_log << TestLog::EndSection; 971 972 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target."); 973 glBindFramebuffer(GL_FRAMEBUFFER, 0); 974 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); 975 expectError(GL_INVALID_OPERATION); 976 m_log << TestLog::EndSection; 977 978 glDeleteRenderbuffers(1, &rbo); 979 glDeleteFramebuffers(1, &fbo); 980 }); 981 ES3F_ADD_API_CASE(framebuffer_texture2d, "Invalid glFramebufferTexture2D() usage", 982 { 983 GLuint fbo; 984 GLuint tex2D; 985 GLuint texCube; 986 glGenFramebuffers(1, &fbo); 987 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 988 glGenTextures(1, &tex2D); 989 glBindTexture(GL_TEXTURE_2D, tex2D); 990 glGenTextures(1, &texCube); 991 glBindTexture(GL_TEXTURE_CUBE_MAP, texCube); 992 expectError(GL_NO_ERROR); 993 994 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 995 glFramebufferTexture2D(-1, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); 996 expectError(GL_INVALID_ENUM); 997 m_log << TestLog::EndSection; 998 999 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if textarget is not an accepted texture target."); 1000 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, tex2D, 0); 1001 expectError(GL_INVALID_ENUM); 1002 m_log << TestLog::EndSection; 1003 1004 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0 or larger than log_2 of maximum texture size."); 1005 int maxSize; 1006 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1); 1007 expectError(GL_INVALID_VALUE); 1008 maxSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1; 1009 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxSize); 1010 expectError(GL_INVALID_VALUE); 1011 maxSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1; 1012 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texCube, maxSize); 1013 expectError(GL_INVALID_VALUE); 1014 m_log << TestLog::EndSection; 1015 1016 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object."); 1017 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, -1, 0); 1018 expectError(GL_INVALID_OPERATION); 1019 m_log << TestLog::EndSection; 1020 1021 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if textarget and texture are not compatible."); 1022 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, tex2D, 0); 1023 expectError(GL_INVALID_OPERATION); 1024 glDeleteTextures(1, &tex2D); 1025 1026 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texCube, 0); 1027 expectError(GL_INVALID_OPERATION); 1028 glDeleteTextures(1, &texCube); 1029 m_log << TestLog::EndSection; 1030 1031 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target."); 1032 glBindFramebuffer(GL_FRAMEBUFFER, 0); 1033 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); 1034 expectError(GL_INVALID_OPERATION); 1035 m_log << TestLog::EndSection; 1036 1037 glDeleteFramebuffers(1, &fbo); 1038 }); 1039 ES3F_ADD_API_CASE(renderbuffer_storage, "Invalid glRenderbufferStorage() usage", 1040 { 1041 deUint32 rbo; 1042 glGenRenderbuffers (1, &rbo); 1043 glBindRenderbuffer (GL_RENDERBUFFER, rbo); 1044 1045 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 1046 glRenderbufferStorage (-1, GL_RGBA4, 1, 1); 1047 expectError (GL_INVALID_ENUM); 1048 glRenderbufferStorage (GL_FRAMEBUFFER, GL_RGBA4, 1, 1); 1049 expectError (GL_INVALID_ENUM); 1050 m_log << TestLog::EndSection; 1051 1052 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format."); 1053 glRenderbufferStorage (GL_RENDERBUFFER, -1, 1, 1); 1054 expectError (GL_INVALID_ENUM); 1055 1056 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error 1057 { 1058 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGB16F, 1, 1); 1059 expectError (GL_INVALID_ENUM); 1060 } 1061 1062 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error 1063 { 1064 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1); 1065 expectError (GL_INVALID_ENUM); 1066 } 1067 1068 m_log << TestLog::EndSection; 1069 1070 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than zero."); 1071 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, 1); 1072 expectError (GL_INVALID_VALUE); 1073 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, -1); 1074 expectError (GL_INVALID_VALUE); 1075 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, -1); 1076 expectError (GL_INVALID_VALUE); 1077 m_log << TestLog::EndSection; 1078 1079 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE."); 1080 GLint maxSize; 1081 glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize); 1082 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, maxSize+1); 1083 expectError (GL_INVALID_VALUE); 1084 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, 1); 1085 expectError (GL_INVALID_VALUE); 1086 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, maxSize+1); 1087 expectError (GL_INVALID_VALUE); 1088 m_log << TestLog::EndSection; 1089 1090 glDeleteRenderbuffers(1, &rbo); 1091 }); 1092 ES3F_ADD_API_CASE(blit_framebuffer, "Invalid glBlitFramebuffer() usage", 1093 { 1094 deUint32 fbo[2]; 1095 deUint32 rbo[2]; 1096 deUint32 texture[2]; 1097 1098 glGenFramebuffers (2, fbo); 1099 glGenTextures (2, texture); 1100 glGenRenderbuffers (2, rbo); 1101 1102 glBindTexture (GL_TEXTURE_2D, texture[0]); 1103 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1104 glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]); 1105 1106 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1107 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); 1108 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1109 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]); 1110 glCheckFramebufferStatus(GL_READ_FRAMEBUFFER); 1111 1112 glBindTexture (GL_TEXTURE_2D, texture[1]); 1113 glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]); 1114 glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1115 1116 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1117 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); 1118 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1119 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[1]); 1120 glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); 1121 expectError (GL_NO_ERROR); 1122 1123 m_log << TestLog::Section("", "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."); 1124 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR); 1125 expectError (GL_INVALID_OPERATION); 1126 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_LINEAR); 1127 expectError (GL_INVALID_OPERATION); 1128 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR); 1129 expectError (GL_INVALID_OPERATION); 1130 m_log << TestLog::EndSection; 1131 1132 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if mask contains GL_COLOR_BUFFER_BIT and read buffer format is incompatible with draw buffer format."); 1133 glBindTexture (GL_TEXTURE_2D, texture[0]); 1134 1135 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 1136 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1137 m_log << TestLog::Message << "// Read buffer: GL_RGBA32UI, draw buffer: GL_RGBA" << TestLog::EndMessage; 1138 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1139 expectError (GL_INVALID_OPERATION); 1140 1141 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 1142 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1143 m_log << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA" << TestLog::EndMessage; 1144 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1145 expectError (GL_INVALID_OPERATION); 1146 1147 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1148 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1149 glBindTexture (GL_TEXTURE_2D, texture[1]); 1150 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL); 1151 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1152 m_log << TestLog::Message << "// Read buffer: GL_RGBA8, draw buffer: GL_RGBA32I" << TestLog::EndMessage; 1153 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1154 expectError (GL_INVALID_OPERATION); 1155 m_log << TestLog::EndSection; 1156 1157 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if filter is GL_LINEAR and the read buffer contains integer data."); 1158 glBindTexture (GL_TEXTURE_2D, texture[0]); 1159 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL); 1160 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0); 1161 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1162 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0); 1163 m_log << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA8" << TestLog::EndMessage; 1164 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_LINEAR); 1165 expectError (GL_INVALID_OPERATION); 1166 m_log << TestLog::EndSection; 1167 1168 m_log << TestLog::Section("", "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."); 1169 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1170 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH32F_STENCIL8, 32, 32); 1171 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]); 1172 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST); 1173 expectError (GL_INVALID_OPERATION); 1174 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_STENCIL_BUFFER_BIT, GL_NEAREST); 1175 expectError (GL_INVALID_OPERATION); 1176 m_log << TestLog::EndSection; 1177 1178 glBindFramebuffer (GL_FRAMEBUFFER, 0); 1179 glDeleteFramebuffers (2, fbo); 1180 glDeleteTextures (2, texture); 1181 glDeleteRenderbuffers (2, rbo); 1182 }); 1183 ES3F_ADD_API_CASE(blit_framebuffer_multisample, "Invalid glBlitFramebuffer() usage", 1184 { 1185 deUint32 fbo[2]; 1186 deUint32 rbo[2]; 1187 1188 glGenFramebuffers (2, fbo); 1189 glGenRenderbuffers (2, rbo); 1190 1191 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]); 1192 glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]); 1193 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 1194 glFramebufferRenderbuffer (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[0]); 1195 glCheckFramebufferStatus (GL_READ_FRAMEBUFFER); 1196 1197 glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]); 1198 glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]); 1199 1200 expectError (GL_NO_ERROR); 1201 1202 if (!m_context.getContextInfo().isExtensionSupported("GL_NV_framebuffer_multisample")) 1203 { 1204 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the value of GL_SAMPLE_BUFFERS for the draw buffer is greater than zero."); 1205 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32); 1206 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1207 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1208 expectError (GL_INVALID_OPERATION); 1209 m_log << TestLog::EndSection; 1210 1211 m_log << TestLog::Section("", "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."); 1212 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 32, 32); 1213 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1214 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1215 expectError (GL_INVALID_OPERATION); 1216 m_log << TestLog::EndSection; 1217 1218 m_log << TestLog::Section("", "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."); 1219 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32); 1220 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]); 1221 glBlitFramebuffer (0, 0, 16, 16, 2, 2, 18, 18, GL_COLOR_BUFFER_BIT, GL_NEAREST); 1222 expectError (GL_INVALID_OPERATION); 1223 m_log << TestLog::EndSection; 1224 } 1225 1226 glBindFramebuffer (GL_FRAMEBUFFER, 0); 1227 glDeleteRenderbuffers (2, rbo); 1228 glDeleteFramebuffers (2, fbo); 1229 }); 1230 ES3F_ADD_API_CASE(framebuffer_texture_layer, "Invalid glFramebufferTextureLayer() usage", 1231 { 1232 deUint32 fbo; 1233 deUint32 tex3D; 1234 deUint32 tex2DArray; 1235 deUint32 tex2D; 1236 1237 glGenFramebuffers (1, &fbo); 1238 glGenTextures (1, &tex3D); 1239 glGenTextures (1, &tex2DArray); 1240 glGenTextures (1, &tex2D); 1241 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1242 1243 glBindTexture (GL_TEXTURE_3D, tex3D); 1244 glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1245 glBindTexture (GL_TEXTURE_2D_ARRAY, tex2DArray); 1246 glTexImage3D (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1247 glBindTexture (GL_TEXTURE_2D, tex2D); 1248 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1249 1250 expectError (GL_NO_ERROR); 1251 1252 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens."); 1253 glFramebufferTextureLayer (-1, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1254 expectError (GL_INVALID_ENUM); 1255 glFramebufferTextureLayer (GL_RENDERBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1256 expectError (GL_INVALID_ENUM); 1257 m_log << TestLog::EndSection; 1258 1259 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens."); 1260 glFramebufferTextureLayer (GL_FRAMEBUFFER, -1, tex3D, 0, 1); 1261 expectError (GL_INVALID_ENUM); 1262 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_BACK, tex3D, 0, 1); 1263 expectError (GL_INVALID_ENUM); 1264 m_log << TestLog::EndSection; 1265 1266 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture is non-zero and not the name of a 3D texture or 2D array texture."); 1267 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0, 0); 1268 expectError (GL_INVALID_OPERATION); 1269 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2D, 0, 0); 1270 expectError (GL_INVALID_OPERATION); 1271 m_log << TestLog::EndSection; 1272 1273 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if texture is not zero and layer is negative."); 1274 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, -1); 1275 expectError (GL_INVALID_VALUE); 1276 m_log << TestLog::EndSection; 1277 1278 m_log << TestLog::Section("", "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."); 1279 int max3DTexSize; 1280 glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE, &max3DTexSize); 1281 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, max3DTexSize); 1282 expectError (GL_INVALID_VALUE); 1283 m_log << TestLog::EndSection; 1284 1285 m_log << TestLog::Section("", "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."); 1286 int maxArrayTexLayers; 1287 glGetIntegerv (GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTexLayers); 1288 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, 0, maxArrayTexLayers); 1289 expectError (GL_INVALID_VALUE); 1290 m_log << TestLog::EndSection; 1291 1292 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target."); 1293 glBindFramebuffer (GL_FRAMEBUFFER, 0); 1294 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1); 1295 expectError (GL_INVALID_OPERATION); 1296 m_log << TestLog::EndSection; 1297 1298 glDeleteTextures (1, &tex3D); 1299 glDeleteTextures (1, &tex2DArray); 1300 glDeleteTextures (1, &tex2D); 1301 glDeleteFramebuffers (1, &fbo); 1302 }); 1303 ES3F_ADD_API_CASE(invalidate_framebuffer, "Invalid glInvalidateFramebuffer() usage", 1304 { 1305 deUint32 fbo; 1306 deUint32 texture; 1307 deUint32 attachments[2]; 1308 int maxColorAttachments; 1309 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 1310 attachments[0] = GL_COLOR_ATTACHMENT0; 1311 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments; 1312 1313 glGenFramebuffers (1, &fbo); 1314 glGenTextures (1, &texture); 1315 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1316 glBindTexture (GL_TEXTURE_2D, texture); 1317 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1318 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 1319 glCheckFramebufferStatus (GL_FRAMEBUFFER); 1320 expectError (GL_NO_ERROR); 1321 1322 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER."); 1323 glInvalidateFramebuffer (-1, 1, &attachments[0]); 1324 expectError (GL_INVALID_ENUM); 1325 glInvalidateFramebuffer (GL_BACK, 1, &attachments[0]); 1326 expectError (GL_INVALID_ENUM); 1327 m_log << TestLog::EndSection; 1328 1329 m_log << TestLog::Section("", "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."); 1330 glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1]); 1331 expectError (GL_INVALID_OPERATION); 1332 m_log << TestLog::EndSection; 1333 1334 glDeleteTextures (1, &texture); 1335 glDeleteFramebuffers (1, &fbo); 1336 }); 1337 ES3F_ADD_API_CASE(invalidate_sub_framebuffer, "Invalid glInvalidateSubFramebuffer() usage", 1338 { 1339 deUint32 fbo; 1340 deUint32 texture; 1341 deUint32 attachments[2]; 1342 int maxColorAttachments; 1343 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments); 1344 attachments[0] = GL_COLOR_ATTACHMENT0; 1345 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments; 1346 1347 glGenFramebuffers (1, &fbo); 1348 glGenTextures (1, &texture); 1349 glBindFramebuffer (GL_FRAMEBUFFER, fbo); 1350 glBindTexture (GL_TEXTURE_2D, texture); 1351 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 1352 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); 1353 glCheckFramebufferStatus (GL_FRAMEBUFFER); 1354 expectError (GL_NO_ERROR); 1355 1356 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER."); 1357 glInvalidateSubFramebuffer (-1, 1, &attachments[0], 0, 0, 16, 16); 1358 expectError (GL_INVALID_ENUM); 1359 glInvalidateSubFramebuffer (GL_BACK, 1, &attachments[0], 0, 0, 16, 16); 1360 expectError (GL_INVALID_ENUM); 1361 m_log << TestLog::EndSection; 1362 1363 m_log << TestLog::Section("", "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."); 1364 glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1], 0, 0, 16, 16); 1365 expectError (GL_INVALID_OPERATION); 1366 m_log << TestLog::EndSection; 1367 1368 glDeleteTextures (1, &texture); 1369 glDeleteFramebuffers (1, &fbo); 1370 }); 1371 ES3F_ADD_API_CASE(renderbuffer_storage_multisample, "Invalid glRenderbufferStorageMultisample() usage", 1372 { 1373 deUint32 rbo; 1374 int maxSamplesSupportedRGBA4 = -1; 1375 1376 glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, 1, &maxSamplesSupportedRGBA4); 1377 glGenRenderbuffers (1, &rbo); 1378 glBindRenderbuffer (GL_RENDERBUFFER, rbo); 1379 1380 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER."); 1381 glRenderbufferStorageMultisample (-1, 2, GL_RGBA4, 1, 1); 1382 expectError (GL_INVALID_ENUM); 1383 glRenderbufferStorageMultisample (GL_FRAMEBUFFER, 2, GL_RGBA4, 1, 1); 1384 expectError (GL_INVALID_ENUM); 1385 m_log << TestLog::EndSection; 1386 1387 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat."); 1388 glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA4+1, GL_RGBA4, 1, 1); 1389 expectError (GL_INVALID_OPERATION); 1390 m_log << TestLog::EndSection; 1391 1392 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format."); 1393 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, -1, 1, 1); 1394 expectError (GL_INVALID_ENUM); 1395 1396 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error 1397 { 1398 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1); 1399 expectError (GL_INVALID_ENUM); 1400 } 1401 1402 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error 1403 { 1404 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1); 1405 expectError (GL_INVALID_ENUM); 1406 } 1407 1408 m_log << TestLog::EndSection; 1409 1410 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than zero."); 1411 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, 1); 1412 expectError (GL_INVALID_VALUE); 1413 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, 1, -1); 1414 expectError (GL_INVALID_VALUE); 1415 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, -1); 1416 expectError (GL_INVALID_VALUE); 1417 m_log << TestLog::EndSection; 1418 1419 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE."); 1420 GLint maxSize; 1421 glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize); 1422 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, 1, maxSize+1); 1423 expectError (GL_INVALID_VALUE); 1424 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, 1); 1425 expectError (GL_INVALID_VALUE); 1426 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, maxSize+1); 1427 expectError (GL_INVALID_VALUE); 1428 m_log << TestLog::EndSection; 1429 1430 glDeleteRenderbuffers(1, &rbo); 1431 }); 1432} 1433 1434} // Functional 1435} // gles3 1436} // deqp 1437