modules/gles3/functional/es3fNegativeBufferApiTests.cpp

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