modules/gles31/functional/es31fNegativeBufferApiTests.cpp

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