modules/gles31/functional/es31fNegativeVertexArrayApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Negative Vertex Array API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fNegativeVertexArrayApiTests.hpp"
  25 #include "gluCallLogWrapper.hpp"
  26 #include "gluContextInfo.hpp"
  27 #include "gluShaderProgram.hpp"
  28 #include "glwDefs.hpp"
  29 #include "glwEnums.hpp"
  30 #include "tcuStringTemplate.hpp"
  31
  32 namespace deqp
  33 {
  34
  35 using std::string;
  36 using std::map;
  37
  38 namespace gles31
  39 {
  40 namespace Functional
  41 {
  42 namespace NegativeTestShared
  43 {
  44
  45 using tcu::TestLog;
  46 using glu::CallLogWrapper;
  47 using namespace glw;
  48
  49 static const char* vertexShaderSource           =       "${GLSL_VERSION_STRING}\n"
  50                                                                                                 "void main (void)\n"
  51                                                                                                 "{\n"
  52                                                                                                 "       gl_Position = vec4(0.0);\n"
  53                                                                                                 "}\n\0";
  54
  55 static const char* fragmentShaderSource         =       "${GLSL_VERSION_STRING}\n"
  56                                                                                                 "layout(location = 0) out mediump vec4 fragColor;"
  57                                                                                                 "void main (void)\n"
  58                                                                                                 "{\n"
  59                                                                                                 "       fragColor = vec4(0.0);\n"
  60                                                                                                 "}\n\0";
  61
  62 static const char* geometryShaderSource         =       "#version 320 es\n"
  63                                                                                                 "layout(points) in;\n"
  64                                                                                                 "layout(points, max_vertices = 3) out;\n"
  65                                                                                                 "void main (void)\n"
  66                                                                                                 "{\n"
  67                                                                                                 "}\n";
  68
  69 void vertex_attribf (NegativeTestContext& ctx)
  70 {
  71         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
  72         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
  73         ctx.glVertexAttrib1f(maxVertexAttribs, 0.0f);
  74         ctx.expectError(GL_INVALID_VALUE);
  75         ctx.glVertexAttrib2f(maxVertexAttribs, 0.0f, 0.0f);
  76         ctx.expectError(GL_INVALID_VALUE);
  77         ctx.glVertexAttrib3f(maxVertexAttribs, 0.0f, 0.0f, 0.0f);
  78         ctx.expectError(GL_INVALID_VALUE);
  79         ctx.glVertexAttrib4f(maxVertexAttribs, 0.0f, 0.0f, 0.0f, 0.0f);
  80         ctx.expectError(GL_INVALID_VALUE);
  81         ctx.endSection();
  82 }
  83
  84 void vertex_attribfv (NegativeTestContext& ctx)
  85 {
  86         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
  87         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
  88         float v[4] = {0.0f};
  89         ctx.glVertexAttrib1fv(maxVertexAttribs, &v[0]);
  90         ctx.expectError(GL_INVALID_VALUE);
  91         ctx.glVertexAttrib2fv(maxVertexAttribs, &v[0]);
  92         ctx.expectError(GL_INVALID_VALUE);
  93         ctx.glVertexAttrib3fv(maxVertexAttribs, &v[0]);
  94         ctx.expectError(GL_INVALID_VALUE);
  95         ctx.glVertexAttrib4fv(maxVertexAttribs, &v[0]);
  96         ctx.expectError(GL_INVALID_VALUE);
  97         ctx.endSection();
  98 }
  99
 100 void vertex_attribi4 (NegativeTestContext& ctx)
 101 {
 102         int maxVertexAttribs    = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 103         GLint valInt                    = 0;
 104         GLuint valUint                  = 0;
 105
 106         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 107         ctx.glVertexAttribI4i(maxVertexAttribs, valInt, valInt, valInt, valInt);
 108         ctx.expectError(GL_INVALID_VALUE);
 109         ctx.glVertexAttribI4ui(maxVertexAttribs, valUint, valUint, valUint, valUint);
 110         ctx.expectError(GL_INVALID_VALUE);
 111         ctx.endSection();
 112 }
 113
 114 void vertex_attribi4v (NegativeTestContext& ctx)
 115 {
 116         int maxVertexAttribs    = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 117         GLint valInt[4]                 = { 0 };
 118         GLuint valUint[4]               = { 0 };
 119
 120         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 121         ctx.glVertexAttribI4iv(maxVertexAttribs, &valInt[0]);
 122         ctx.expectError(GL_INVALID_VALUE);
 123         ctx.glVertexAttribI4uiv(maxVertexAttribs, &valUint[0]);
 124         ctx.expectError(GL_INVALID_VALUE);
 125         ctx.endSection();
 126 }
 127
 128 void vertex_attrib_pointer (NegativeTestContext& ctx)
 129 {
 130         ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value.");
 131         ctx.glVertexAttribPointer(0, 1, 0, GL_TRUE, 0, 0);
 132         ctx.expectError(GL_INVALID_ENUM);
 133         ctx.endSection();
 134
 135         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 136         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 137         ctx.glVertexAttribPointer(maxVertexAttribs, 1, GL_BYTE, GL_TRUE, 0, 0);
 138         ctx.expectError(GL_INVALID_VALUE);
 139         ctx.endSection();
 140
 141         ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4.");
 142         ctx.glVertexAttribPointer(0, 0, GL_BYTE, GL_TRUE, 0, 0);
 143         ctx.expectError(GL_INVALID_VALUE);
 144         ctx.endSection();
 145
 146         ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative.");
 147         ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, -1, 0);
 148         ctx.expectError(GL_INVALID_VALUE);
 149         ctx.endSection();
 150
 151         ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV or GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4.");
 152         ctx.glVertexAttribPointer(0, 2, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
 153         ctx.expectError(GL_INVALID_OPERATION);
 154         ctx.glVertexAttribPointer(0, 2, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
 155         ctx.expectError(GL_INVALID_OPERATION);
 156         ctx.glVertexAttribPointer(0, 4, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
 157         ctx.expectError(GL_NO_ERROR);
 158         ctx.glVertexAttribPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
 159         ctx.expectError(GL_NO_ERROR);
 160         ctx.endSection();
 161
 162         ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL.");
 163         GLuint vao = 0;
 164         GLbyte offset = 1;
 165         ctx.glGenVertexArrays(1, &vao);
 166         ctx.glBindVertexArray(vao);
 167         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 168         ctx.expectError(GL_NO_ERROR);
 169
 170         ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, 0, &offset);
 171         ctx.expectError(GL_INVALID_OPERATION);
 172
 173         ctx.glBindVertexArray(0);
 174         ctx.glDeleteVertexArrays(1, &vao);
 175         ctx.expectError(GL_NO_ERROR);
 176         ctx.endSection();
 177 }
 178
 179 void vertex_attrib_i_pointer (NegativeTestContext& ctx)
 180 {
 181         ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value.");
 182         ctx.glVertexAttribIPointer(0, 1, 0, 0, 0);
 183         ctx.expectError(GL_INVALID_ENUM);
 184         ctx.glVertexAttribIPointer(0, 4, GL_INT_2_10_10_10_REV, 0, 0);
 185         ctx.expectError(GL_INVALID_ENUM);
 186         ctx.glVertexAttribIPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, 0);
 187         ctx.expectError(GL_INVALID_ENUM);
 188         ctx.endSection();
 189
 190         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 191         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 192         ctx.glVertexAttribIPointer(maxVertexAttribs, 1, GL_BYTE, 0, 0);
 193         ctx.expectError(GL_INVALID_VALUE);
 194         ctx.endSection();
 195
 196         ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4.");
 197         ctx.glVertexAttribIPointer(0, 0, GL_BYTE, 0, 0);
 198         ctx.expectError(GL_INVALID_VALUE);
 199         ctx.endSection();
 200
 201         ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative.");
 202         ctx.glVertexAttribIPointer(0, 1, GL_BYTE, -1, 0);
 203         ctx.expectError(GL_INVALID_VALUE);
 204         ctx.endSection();
 205
 206         ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL.");
 207         GLuint vao = 0;
 208         GLbyte offset = 1;
 209         ctx.glGenVertexArrays(1, &vao);
 210         ctx.glBindVertexArray(vao);
 211         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 212         ctx.expectError(GL_NO_ERROR);
 213
 214         ctx.glVertexAttribIPointer(0, 1, GL_BYTE, 0, &offset);
 215         ctx.expectError(GL_INVALID_OPERATION);
 216
 217         ctx.glBindVertexArray(0);
 218         ctx.glDeleteVertexArrays(1, &vao);
 219         ctx.expectError(GL_NO_ERROR);
 220         ctx.endSection();
 221 }
 222
 223 void vertex_attrib_format (NegativeTestContext& ctx)
 224 {
 225         int             maxVertexAttribs                                = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 226         int             maxVertexAttribRelativeOffset   = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET);
 227         GLuint  vao                                                             = 0;
 228
 229         ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of MAX_VERTEX_ATTRIBS.");
 230         ctx.glGenVertexArrays(1, &vao);
 231         ctx.glBindVertexArray(vao);
 232         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 233         ctx.glVertexAttribFormat(maxVertexAttribs, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset);
 234         ctx.expectError(GL_INVALID_VALUE);
 235         ctx.endSection();
 236
 237         ctx.beginSection("GL_INVALID_VALUE is generated if size is not one of 1, 2, 3, 4.");
 238         ctx.glGenVertexArrays(1, &vao);
 239         ctx.glBindVertexArray(vao);
 240         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 241         ctx.glVertexAttribFormat(1, 0, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset);
 242         ctx.expectError(GL_INVALID_VALUE);
 243         ctx.endSection();
 244
 245         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed.");
 246         ctx.glGenVertexArrays(1, &vao);
 247         ctx.glBindVertexArray(vao);
 248         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 249         ctx.glVertexAttribFormat(1, 4, 1, GL_FALSE, 0);
 250         ctx.expectError(GL_INVALID_ENUM);
 251         ctx.endSection();
 252
 253         ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed.");
 254         ctx.glGenVertexArrays(1, &vao);
 255         ctx.glBindVertexArray(0);
 256         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 257         ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, 0);
 258         ctx.expectError(GL_INVALID_OPERATION);
 259         ctx.endSection();
 260
 261         ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV and size is not 4.");
 262         ctx.glGenVertexArrays(1, &vao);
 263         ctx.glBindVertexArray(vao);
 264         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 265         ctx.glVertexAttribFormat(1, 3, GL_INT_2_10_10_10_REV, GL_FALSE, 0);
 266         ctx.expectError(GL_INVALID_OPERATION);
 267         ctx.endSection();
 268
 269         ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4.");
 270         ctx.glGenVertexArrays(1, &vao);
 271         ctx.glBindVertexArray(vao);
 272         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 273         ctx.glVertexAttribFormat(1, 3, GL_UNSIGNED_INT_2_10_10_10_REV, GL_FALSE, 0);
 274         ctx.expectError(GL_INVALID_OPERATION);
 275         ctx.endSection();
 276
 277         ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.");
 278         ctx.glGenVertexArrays(1, &vao);
 279         ctx.glBindVertexArray(vao);
 280         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 281         ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset + 1);
 282         ctx.expectError(GL_INVALID_VALUE);
 283         ctx.endSection();
 284 }
 285
 286 void vertex_attrib_i_format (NegativeTestContext& ctx)
 287 {
 288         int             maxVertexAttribs                                = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 289         int             maxVertexAttribRelativeOffset   = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET);
 290         GLuint  vao                                                             = 0;
 291
 292         ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of GL_MAX_VERTEX_ATTRIBS.");
 293         ctx.glGenVertexArrays(1, &vao);
 294         ctx.glBindVertexArray(vao);
 295         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 296         ctx.glVertexAttribIFormat(maxVertexAttribs, 4, GL_INT, 0);
 297         ctx.expectError(GL_INVALID_VALUE);
 298         ctx.endSection();
 299
 300         ctx.beginSection("GL_INVALID_VALUE is generated if size is not one the values 1, 2, 3, 4.");
 301         ctx.glGenVertexArrays(1, &vao);
 302         ctx.glBindVertexArray(vao);
 303         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 304         ctx.glVertexAttribIFormat(1, 0, GL_INT, 0);
 305         ctx.expectError(GL_INVALID_VALUE);
 306         ctx.endSection();
 307
 308         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed.");
 309         ctx.glGenVertexArrays(1, &vao);
 310         ctx.glBindVertexArray(vao);
 311         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 312         ctx.glVertexAttribIFormat(1, 4, GL_FLOAT, 0);
 313         ctx.expectError(GL_INVALID_ENUM);
 314         ctx.endSection();
 315
 316         ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed.");
 317         ctx.glGenVertexArrays(1, &vao);
 318         ctx.glBindVertexArray(0);
 319         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 320         ctx.glVertexAttribIFormat(1, 4, GL_INT, 0);
 321         ctx.expectError(GL_INVALID_OPERATION);
 322         ctx.endSection();
 323
 324         ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.");
 325         ctx.glGenVertexArrays(1, &vao);
 326         ctx.glBindVertexArray(vao);
 327         ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 328         ctx.glVertexAttribIFormat(1, 4, GL_INT, maxVertexAttribRelativeOffset + 1);
 329         ctx.expectError(GL_INVALID_VALUE);
 330         ctx.endSection();
 331 }
 332
 333 void enable_vertex_attrib_array (NegativeTestContext& ctx)
 334 {
 335         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 336
 337         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 338         ctx.glEnableVertexAttribArray(maxVertexAttribs);
 339         ctx.expectError(GL_INVALID_VALUE);
 340         ctx.endSection();
 341 }
 342
 343 void disable_vertex_attrib_array (NegativeTestContext& ctx)
 344 {
 345         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 346
 347         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 348         ctx.glDisableVertexAttribArray(maxVertexAttribs);
 349         ctx.expectError(GL_INVALID_VALUE);
 350         ctx.endSection();
 351 }
 352
 353 void gen_vertex_arrays (NegativeTestContext& ctx)
 354 {
 355         GLuint arrays = 0;
 356
 357         ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
 358         ctx.glGenVertexArrays(-1, &arrays);
 359         ctx.expectError(GL_INVALID_VALUE);
 360         ctx.endSection();
 361 }
 362
 363 void bind_vertex_array (NegativeTestContext& ctx)
 364 {
 365         ctx.beginSection("GL_INVALID_OPERATION is generated if array is not zero or the name of an existing vertex array object.");
 366         ctx.glBindVertexArray(-1);
 367         ctx.expectError(GL_INVALID_OPERATION);
 368         ctx.endSection();
 369 }
 370
 371 void delete_vertex_arrays (NegativeTestContext& ctx)
 372 {
 373         ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
 374         ctx.glDeleteVertexArrays(-1, 0);
 375         ctx.expectError(GL_INVALID_VALUE);
 376         ctx.endSection();
 377 }
 378
 379 void vertex_attrib_divisor (NegativeTestContext& ctx)
 380 {
 381         int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
 382
 383         ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 384         ctx.glVertexAttribDivisor(maxVertexAttribs, 0);
 385         ctx.expectError(GL_INVALID_VALUE);
 386         ctx.endSection();
 387 }
 388
 389 void draw_arrays (NegativeTestContext& ctx)
 390 {
 391         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 392         GLuint                                          fbo             = 0;
 393         map<string, string>                     args;
 394         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 395         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 396
 397         ctx.glUseProgram(program.getProgram());
 398         ctx.expectError(GL_NO_ERROR);
 399
 400         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 401         ctx.glDrawArrays(-1, 0, 1);
 402         ctx.expectError(GL_INVALID_ENUM);
 403         ctx.endSection();
 404
 405         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 406         ctx.glDrawArrays(GL_POINTS, 0, -1);
 407         ctx.expectError(GL_INVALID_VALUE);
 408         ctx.endSection();
 409
 410         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 411         ctx.glGenFramebuffers(1, &fbo);
 412         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 413         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 414         ctx.glDrawArrays(GL_POINTS, 0, 1);
 415         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 416         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 417         ctx.glDeleteFramebuffers(1, &fbo);
 418         ctx.endSection();
 419
 420         ctx.glUseProgram(0);
 421 }
 422
 423 void draw_arrays_invalid_program (NegativeTestContext& ctx)
 424 {
 425         GLuint fbo = 0;
 426         ctx.glUseProgram(0);
 427
 428         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 429         ctx.glDrawArrays(-1, 0, 1);
 430         ctx.expectError(GL_INVALID_ENUM);
 431         ctx.endSection();
 432
 433         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 434         ctx.glDrawArrays(GL_POINTS, 0, -1);
 435         ctx.expectError(GL_INVALID_VALUE);
 436         ctx.endSection();
 437
 438         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 439         ctx.glGenFramebuffers(1, &fbo);
 440         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 441         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 442         ctx.glDrawArrays(GL_POINTS, 0, 1);
 443         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 444         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 445         ctx.glDeleteFramebuffers(1, &fbo);
 446         ctx.endSection();
 447 }
 448
 449 void draw_arrays_incomplete_primitive (NegativeTestContext& ctx)
 450 {
 451         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 452         GLuint                                          fbo             = 0;
 453         map<string, string>                     args;
 454         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 455         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 456
 457         ctx.glUseProgram(program.getProgram());
 458         ctx.expectError(GL_NO_ERROR);
 459
 460         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 461         ctx.glDrawArrays(-1, 0, 1);
 462         ctx.expectError(GL_INVALID_ENUM);
 463         ctx.endSection();
 464
 465         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 466         ctx.glDrawArrays(GL_TRIANGLES, 0, -1);
 467         ctx.expectError(GL_INVALID_VALUE);
 468         ctx.endSection();
 469
 470         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 471         ctx.glGenFramebuffers(1, &fbo);
 472         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 473         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 474         ctx.glDrawArrays(GL_TRIANGLES, 0, 1);
 475         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 476         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 477         ctx.glDeleteFramebuffers(1, &fbo);
 478         ctx.endSection();
 479
 480         ctx.glUseProgram(0);
 481 }
 482
 483 void draw_elements (NegativeTestContext& ctx)
 484 {
 485         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 486         GLuint                                          fbo             = 0;
 487         GLuint                                          buf             = 0;
 488         GLuint                                          tfID    = 0;
 489         GLfloat                                         vertices[1];
 490         map<string, string>                     args;
 491         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 492         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 493
 494         ctx.glUseProgram(program.getProgram());
 495         ctx.expectError(GL_NO_ERROR);
 496
 497         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 498         ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
 499         ctx.expectError(GL_INVALID_ENUM);
 500         ctx.endSection();
 501
 502         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 503         ctx.glDrawElements(GL_POINTS, 1, -1, vertices);
 504         ctx.expectError(GL_INVALID_ENUM);
 505         ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, vertices);
 506         ctx.expectError(GL_INVALID_ENUM);
 507         ctx.endSection();
 508
 509         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 510         ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices);
 511         ctx.expectError(GL_INVALID_VALUE);
 512         ctx.endSection();
 513
 514         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 515         ctx.glGenFramebuffers(1, &fbo);
 516         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 517         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 518         ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
 519         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 520         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 521         ctx.glDeleteFramebuffers(1, &fbo);
 522         ctx.endSection();
 523
 524         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
 525         {
 526                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
 527                 const char* tfVarying = "gl_Position";
 528
 529                 ctx.glGenBuffers(1, &buf);
 530                 ctx.glGenTransformFeedbacks(1, &tfID);
 531
 532                 ctx.glUseProgram(program.getProgram());
 533                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
 534                 ctx.glLinkProgram(program.getProgram());
 535                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
 536                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
 537                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
 538                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
 539                 ctx.glBeginTransformFeedback(GL_POINTS);
 540                 ctx.expectError(GL_NO_ERROR);
 541
 542                 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
 543                 ctx.expectError(GL_INVALID_OPERATION);
 544
 545                 ctx.glPauseTransformFeedback();
 546                 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
 547                 ctx.expectError(GL_NO_ERROR);
 548
 549                 ctx.glEndTransformFeedback();
 550                 ctx.glDeleteBuffers(1, &buf);
 551                 ctx.glDeleteTransformFeedbacks(1, &tfID);
 552                 ctx.expectError(GL_NO_ERROR);
 553                 ctx.endSection();
 554         }
 555
 556         ctx.glUseProgram(0);
 557 }
 558
 559 void draw_elements_invalid_program (NegativeTestContext& ctx)
 560 {
 561         ctx.glUseProgram(0);
 562         GLuint  fbo = 0;
 563         GLfloat vertices[1];
 564
 565         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 566         ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
 567         ctx.expectError(GL_INVALID_ENUM);
 568         ctx.endSection();
 569
 570         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 571         ctx.glDrawElements(GL_POINTS, 1, -1, vertices);
 572         ctx.expectError(GL_INVALID_ENUM);
 573         ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, vertices);
 574         ctx.expectError(GL_INVALID_ENUM);
 575         ctx.endSection();
 576
 577         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 578         ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices);
 579         ctx.expectError(GL_INVALID_VALUE);
 580         ctx.endSection();
 581
 582         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 583         ctx.glGenFramebuffers(1, &fbo);
 584         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 585         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 586         ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
 587         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 588         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 589         ctx.glDeleteFramebuffers(1, &fbo);
 590         ctx.endSection();
 591 }
 592
 593 void draw_elements_incomplete_primitive (NegativeTestContext& ctx)
 594 {
 595         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 596         GLuint                                          fbo             = 0;
 597         GLuint                                          buf             = 0;
 598         GLuint                                          tfID    = 0;
 599         GLfloat                                         vertices[1];
 600         map<string, string>                     args;
 601         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 602         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 603
 604         ctx.glUseProgram(program.getProgram());
 605         ctx.expectError(GL_NO_ERROR);
 606
 607         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 608         ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
 609         ctx.expectError(GL_INVALID_ENUM);
 610         ctx.endSection();
 611
 612         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 613         ctx.glDrawElements(GL_TRIANGLES, 1, -1, vertices);
 614         ctx.expectError(GL_INVALID_ENUM);
 615         ctx.glDrawElements(GL_TRIANGLES, 1, GL_FLOAT, vertices);
 616         ctx.expectError(GL_INVALID_ENUM);
 617         ctx.endSection();
 618
 619         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 620         ctx.glDrawElements(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, vertices);
 621         ctx.expectError(GL_INVALID_VALUE);
 622         ctx.endSection();
 623
 624         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 625         ctx.glGenFramebuffers(1, &fbo);
 626         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 627         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 628         ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
 629         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 630         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 631         ctx.glDeleteFramebuffers(1, &fbo);
 632         ctx.endSection();
 633
 634         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
 635         {
 636                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
 637                 const char* tfVarying= "gl_Position";
 638
 639                 ctx.glGenBuffers(1, &buf);
 640                 ctx.glGenTransformFeedbacks(1, &tfID);
 641
 642                 ctx.glUseProgram(program.getProgram());
 643                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
 644                 ctx.glLinkProgram(program.getProgram());
 645                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
 646                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
 647                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
 648                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
 649                 ctx.glBeginTransformFeedback(GL_TRIANGLES);
 650                 ctx.expectError(GL_NO_ERROR);
 651
 652                 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
 653                 ctx.expectError(GL_INVALID_OPERATION);
 654
 655                 ctx.glPauseTransformFeedback();
 656                 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
 657                 ctx.expectError(GL_NO_ERROR);
 658
 659                 ctx.glEndTransformFeedback();
 660                 ctx.glDeleteBuffers(1, &buf);
 661                 ctx.glDeleteTransformFeedbacks(1, &tfID);
 662                 ctx.expectError(GL_NO_ERROR);
 663                 ctx.endSection();
 664         }
 665
 666         ctx.glUseProgram(0);
 667 }
 668
 669 void draw_elements_base_vertex (NegativeTestContext& ctx)
 670 {
 671         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
 672
 673         GLuint                          fbo = 0;
 674         GLfloat                         vertices[1];
 675
 676         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 677         ctx.glDrawElementsBaseVertex(-1, 1, GL_UNSIGNED_INT, vertices, 1);
 678         ctx.expectError(GL_INVALID_ENUM);
 679         ctx.endSection();
 680
 681         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 682         ctx.glDrawElementsBaseVertex(GL_POINTS, 1, -1, vertices, 1);
 683         ctx.expectError(GL_INVALID_ENUM);
 684         ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_FLOAT, vertices, 1);
 685         ctx.expectError(GL_INVALID_ENUM);
 686         ctx.endSection();
 687
 688         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
 689         ctx.glDrawElementsBaseVertex(GL_POINTS, -1, GL_UNSIGNED_INT, vertices, 1);
 690         ctx.expectError(GL_INVALID_VALUE);
 691         ctx.endSection();
 692
 693         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 694         ctx.glGenFramebuffers(1, &fbo);
 695         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 696         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 697         ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_UNSIGNED_INT, vertices, 1);
 698         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 699         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 700         ctx.glDeleteFramebuffers(1, &fbo);
 701         ctx.endSection();
 702 }
 703
 704 void draw_elements_base_vertex_invalid_map (NegativeTestContext& ctx)
 705 {
 706         GLuint  buf = 0;
 707         GLfloat vertices[1];
 708
 709         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped.");
 710         ctx.glGenBuffers(1, &buf);
 711         ctx.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf);
 712         ctx.glBufferData(GL_ELEMENT_ARRAY_BUFFER, 10, 0, GL_STATIC_DRAW);
 713         ctx.glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT);
 714         ctx.expectError(GL_NO_ERROR);
 715         ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_UNSIGNED_INT, vertices, 1);
 716         ctx.expectError(GL_INVALID_OPERATION);
 717         ctx.glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
 718         ctx.glDeleteBuffers(1, &buf);
 719         ctx.endSection();
 720 }
 721
 722 void draw_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
 723 {
 724         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
 725
 726         GLfloat                                         vertices[1];
 727         map<string, string>                     args;
 728         args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
 729
 730         glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
 731
 732         ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
 733         ctx.glUseProgram(program.getProgram());
 734         ctx.glDrawElementsBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, vertices, 1);
 735         ctx.expectError(GL_INVALID_OPERATION);
 736         ctx.endSection();
 737
 738         ctx.glUseProgram(0);
 739 }
 740
 741 void draw_arrays_instanced (NegativeTestContext& ctx)
 742 {
 743         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 744         GLuint                                          fbo             = 0;
 745         map<string, string>                     args;
 746         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 747         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 748
 749         ctx.glUseProgram(program.getProgram());
 750         ctx.expectError(GL_NO_ERROR);
 751         ctx.glVertexAttribDivisor(0, 1);
 752         ctx.expectError(GL_NO_ERROR);
 753
 754         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 755         ctx.glDrawArraysInstanced(-1, 0, 1, 1);
 756         ctx.expectError(GL_INVALID_ENUM);
 757         ctx.endSection();
 758
 759         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 760         ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
 761         ctx.expectError(GL_INVALID_VALUE);
 762         ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
 763         ctx.expectError(GL_INVALID_VALUE);
 764         ctx.endSection();
 765
 766         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 767         ctx.glGenFramebuffers(1, &fbo);
 768         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 769         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 770         ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
 771         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 772         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 773         ctx.glDeleteFramebuffers(1, &fbo);
 774         ctx.endSection();
 775
 776         ctx.glUseProgram(0);
 777 }
 778
 779 void draw_arrays_instanced_invalid_program (NegativeTestContext& ctx)
 780 {
 781         ctx.glUseProgram(0);
 782         GLuint fbo = 0;
 783         ctx.glVertexAttribDivisor(0, 1);
 784         ctx.expectError(GL_NO_ERROR);
 785
 786         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 787         ctx.glDrawArraysInstanced(-1, 0, 1, 1);
 788         ctx.expectError(GL_INVALID_ENUM);
 789         ctx.endSection();
 790
 791         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 792         ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
 793         ctx.expectError(GL_INVALID_VALUE);
 794         ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
 795         ctx.expectError(GL_INVALID_VALUE);
 796         ctx.endSection();
 797
 798         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 799         ctx.glGenFramebuffers(1, &fbo);
 800         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 801         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 802         ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
 803         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 804         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 805         ctx.glDeleteFramebuffers(1, &fbo);
 806         ctx.endSection();
 807 }
 808
 809 void draw_arrays_instanced_incomplete_primitive (NegativeTestContext& ctx)
 810 {
 811         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 812         GLuint                                          fbo             = 0;
 813         map<string, string>                     args;
 814         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 815         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 816
 817         ctx.glVertexAttribDivisor(0, 1);
 818         ctx.expectError(GL_NO_ERROR);
 819
 820         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 821         ctx.glDrawArraysInstanced(-1, 0, 1, 1);
 822         ctx.expectError(GL_INVALID_ENUM);
 823         ctx.endSection();
 824
 825         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 826         ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, -1, 1);
 827         ctx.expectError(GL_INVALID_VALUE);
 828         ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, -1);
 829         ctx.expectError(GL_INVALID_VALUE);
 830         ctx.endSection();
 831
 832         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 833         ctx.glGenFramebuffers(1, &fbo);
 834         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 835         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 836         ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, 1);
 837         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 838         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 839         ctx.glDeleteFramebuffers(1, &fbo);
 840         ctx.endSection();
 841
 842         ctx.glUseProgram(0);
 843 }
 844
 845 void draw_elements_instanced (NegativeTestContext& ctx)
 846 {
 847         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 848         GLuint                                          fbo             = 0;
 849         GLuint                                          buf             = 0;
 850         GLuint                                          tfID    = 0;
 851         GLfloat                                         vertices[1];
 852         map<string, string>                     args;
 853         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 854         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 855
 856         ctx.glUseProgram(program.getProgram());
 857         ctx.glVertexAttribDivisor(0, 1);
 858         ctx.expectError(GL_NO_ERROR);
 859
 860         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 861         ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1);
 862         ctx.expectError(GL_INVALID_ENUM);
 863         ctx.endSection();
 864
 865         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 866         ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, vertices, 1);
 867         ctx.expectError(GL_INVALID_ENUM);
 868         ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, vertices, 1);
 869         ctx.expectError(GL_INVALID_ENUM);
 870         ctx.endSection();
 871
 872         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 873         ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1);
 874         ctx.expectError(GL_INVALID_VALUE);
 875         ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1);
 876         ctx.expectError(GL_INVALID_VALUE);
 877         ctx.endSection();
 878
 879         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 880         ctx.glGenFramebuffers(1, &fbo);
 881         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 882         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 883         ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
 884         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 885         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 886         ctx.glDeleteFramebuffers(1, &fbo);
 887         ctx.endSection();
 888
 889         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
 890         {
 891                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
 892                 const char* tfVarying = "gl_Position";
 893
 894                 ctx.glGenBuffers(1, &buf);
 895                 ctx.glGenTransformFeedbacks(1, &tfID);
 896
 897                 ctx.glUseProgram(program.getProgram());
 898                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
 899                 ctx.glLinkProgram(program.getProgram());
 900                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
 901                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
 902                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
 903                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
 904                 ctx.glBeginTransformFeedback(GL_POINTS);
 905                 ctx.expectError(GL_NO_ERROR);
 906
 907                 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
 908                 ctx.expectError(GL_INVALID_OPERATION);
 909
 910                 ctx.glPauseTransformFeedback();
 911                 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
 912                 ctx.expectError(GL_NO_ERROR);
 913
 914                 ctx.glEndTransformFeedback();
 915                 ctx.glDeleteBuffers(1, &buf);
 916                 ctx.glDeleteTransformFeedbacks(1, &tfID);
 917                 ctx.expectError(GL_NO_ERROR);
 918                 ctx.endSection();
 919         }
 920
 921         ctx.glUseProgram(0);
 922 }
 923
 924 void draw_elements_instanced_invalid_program (NegativeTestContext& ctx)
 925 {
 926         ctx.glUseProgram(0);
 927         GLuint fbo = 0;
 928         GLfloat vertices[1];
 929         ctx.glVertexAttribDivisor(0, 1);
 930         ctx.expectError(GL_NO_ERROR);
 931
 932         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 933         ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1);
 934         ctx.expectError(GL_INVALID_ENUM);
 935         ctx.endSection();
 936
 937         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 938         ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, vertices, 1);
 939         ctx.expectError(GL_INVALID_ENUM);
 940         ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, vertices, 1);
 941         ctx.expectError(GL_INVALID_ENUM);
 942         ctx.endSection();
 943
 944         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 945         ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1);
 946         ctx.expectError(GL_INVALID_VALUE);
 947         ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1);
 948         ctx.expectError(GL_INVALID_VALUE);
 949         ctx.endSection();
 950
 951         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 952         ctx.glGenFramebuffers(1, &fbo);
 953         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 954         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 955         ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
 956         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 957         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 958         ctx.glDeleteFramebuffers(1, &fbo);
 959         ctx.endSection();
 960 }
 961
 962 void draw_elements_instanced_incomplete_primitive (NegativeTestContext& ctx)
 963 {
 964         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
 965         GLuint                                          fbo             = 0;
 966         GLuint                                          buf             = 0;
 967         GLuint                                          tfID    = 0;
 968         GLfloat                                         vertices[1];
 969         map<string, string>                     args;
 970         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 971         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
 972
 973         ctx.glUseProgram(program.getProgram());
 974         ctx.glVertexAttribDivisor(0, 1);
 975         ctx.expectError(GL_NO_ERROR);
 976
 977         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
 978         ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, vertices, 1);
 979         ctx.expectError(GL_INVALID_ENUM);
 980         ctx.endSection();
 981
 982         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
 983         ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, -1, vertices, 1);
 984         ctx.expectError(GL_INVALID_ENUM);
 985         ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_FLOAT, vertices, 1);
 986         ctx.expectError(GL_INVALID_ENUM);
 987         ctx.endSection();
 988
 989         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
 990         ctx.glDrawElementsInstanced(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, vertices, 1);
 991         ctx.expectError(GL_INVALID_VALUE);
 992         ctx.glDrawElementsInstanced(GL_TRIANGLES, 11, GL_UNSIGNED_BYTE, vertices, -1);
 993         ctx.expectError(GL_INVALID_VALUE);
 994         ctx.endSection();
 995
 996         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 997         ctx.glGenFramebuffers(1, &fbo);
 998         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 999         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1000         ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
1001         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1002         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1003         ctx.glDeleteFramebuffers(1, &fbo);
1004         ctx.endSection();
1005
1006         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
1007         {
1008                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
1009                 const char* tfVarying= "gl_Position";
1010
1011                 ctx.glGenBuffers(1, &buf);
1012                 ctx.glGenTransformFeedbacks(1, &tfID);
1013
1014                 ctx.glUseProgram(program.getProgram());
1015                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1016                 ctx.glLinkProgram(program.getProgram());
1017                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1018                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1019                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1020                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1021                 ctx.glBeginTransformFeedback(GL_TRIANGLES);
1022                 ctx.expectError(GL_NO_ERROR);
1023
1024                 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
1025                 ctx.expectError(GL_INVALID_OPERATION);
1026
1027                 ctx.glPauseTransformFeedback();
1028                 ctx.glDrawElementsInstanced     (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
1029                 ctx.expectError(GL_NO_ERROR);
1030
1031                 ctx.glEndTransformFeedback();
1032                 ctx.glDeleteBuffers(1, &buf);
1033                 ctx.glDeleteTransformFeedbacks(1, &tfID);
1034                 ctx.expectError(GL_NO_ERROR);
1035                 ctx.endSection();
1036         }
1037
1038         ctx.glUseProgram(0);
1039 }
1040
1041 void draw_elements_instanced_base_vertex (NegativeTestContext& ctx)
1042 {
1043         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
1044
1045         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1046         GLuint                                          fbo             = 0;
1047         GLfloat                                         vertices[1];
1048         map<string, string>                     args;
1049         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1050         glu::ShaderProgram                      program                 (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1051
1052         ctx.glUseProgram(program.getProgram());
1053         ctx.glVertexAttribDivisor(0, 1);
1054         ctx.expectError(GL_NO_ERROR);
1055
1056         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1057         ctx.glDrawElementsInstancedBaseVertex(-1, 1, GL_UNSIGNED_BYTE, vertices, 1, 1);
1058         ctx.expectError(GL_INVALID_ENUM);
1059         ctx.endSection();
1060
1061         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1062         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, -1, vertices, 1, 1);
1063         ctx.expectError(GL_INVALID_ENUM);
1064         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_FLOAT, vertices, 1, 1);
1065         ctx.expectError(GL_INVALID_ENUM);
1066         ctx.endSection();
1067
1068         ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
1069         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, -1, GL_UNSIGNED_BYTE, vertices, 1, 1);
1070         ctx.expectError(GL_INVALID_VALUE);
1071         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 11, GL_UNSIGNED_BYTE, vertices, -1, 1);
1072         ctx.expectError(GL_INVALID_VALUE);
1073         ctx.endSection();
1074
1075         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1076         ctx.glGenFramebuffers(1, &fbo);
1077         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1078         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1079         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1, 1);
1080         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1081         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1082         ctx.glDeleteFramebuffers(1, &fbo);
1083         ctx.endSection();
1084
1085         ctx.glUseProgram(0);
1086 }
1087
1088 void draw_elements_instanced_base_vertex_invalid_map (NegativeTestContext& ctx)
1089 {
1090         GLfloat                                         vertices[1];
1091         GLuint                                          buf             = 0;
1092
1093         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped.");
1094         ctx.glGenBuffers(1, &buf);
1095         ctx.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf);
1096         ctx.glBufferData(GL_ELEMENT_ARRAY_BUFFER, 10, 0, GL_STATIC_DRAW);
1097         ctx.glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT);
1098         ctx.expectError(GL_NO_ERROR);
1099         ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_UNSIGNED_INT, vertices, 1, 1);
1100         ctx.expectError(GL_INVALID_OPERATION);
1101         ctx.glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
1102         ctx.glDeleteBuffers(1, &buf);
1103         ctx.endSection();
1104
1105 }
1106
1107 void draw_elements_instanced_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
1108 {
1109         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
1110
1111         GLfloat                                         vertices[1];
1112         map<string, string>                     args;
1113         args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1114         glu::ShaderProgram                      geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
1115
1116         ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
1117         ctx.glUseProgram(geometryProgram.getProgram());
1118         ctx.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, vertices, 1, 1);
1119         ctx.expectError(GL_INVALID_OPERATION);
1120         ctx.endSection();
1121
1122         ctx.glUseProgram(0);
1123 }
1124
1125 void draw_range_elements (NegativeTestContext& ctx)
1126 {
1127         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1128         GLuint                                          fbo             = 0;
1129         GLuint                                          buf             = 0;
1130         GLuint                                          tfID    = 0;
1131         GLfloat                                         vertices[1];
1132         map<string, string>                     args;
1133         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1134         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1135
1136         ctx.glUseProgram(program.getProgram());
1137         ctx.expectError(GL_NO_ERROR);
1138
1139         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1140         ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1141         ctx.expectError(GL_INVALID_ENUM);
1142         ctx.endSection();
1143
1144         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1145         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, vertices);
1146         ctx.expectError(GL_INVALID_ENUM);
1147         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices);
1148         ctx.expectError(GL_INVALID_ENUM);
1149         ctx.endSection();
1150
1151         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1152         ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices);
1153         ctx.expectError(GL_INVALID_VALUE);
1154         ctx.endSection();
1155
1156         ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1157         ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices);
1158         ctx.expectError(GL_INVALID_VALUE);
1159         ctx.endSection();
1160
1161         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1162         ctx.glGenFramebuffers(1, &fbo);
1163         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1164         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1165         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1166         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1167         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1168         ctx.glDeleteFramebuffers(1, &fbo);
1169         ctx.endSection();
1170
1171         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
1172         {
1173                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
1174                 const char* tfVarying= "gl_Position";
1175
1176                 ctx.glGenBuffers(1, &buf);
1177                 ctx.glGenTransformFeedbacks(1, &tfID);
1178
1179                 ctx.glUseProgram(program.getProgram());
1180                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1181                 ctx.glLinkProgram(program.getProgram());
1182                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1183                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1184                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1185                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1186                 ctx.glBeginTransformFeedback(GL_POINTS);
1187                 ctx.expectError(GL_NO_ERROR);
1188
1189                 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1190                 ctx.expectError(GL_INVALID_OPERATION);
1191
1192                 ctx.glPauseTransformFeedback();
1193                 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1194                 ctx.expectError(GL_NO_ERROR);
1195
1196                 ctx.glEndTransformFeedback();
1197                 ctx.glDeleteBuffers(1, &buf);
1198                 ctx.glDeleteTransformFeedbacks(1, &tfID);
1199                 ctx.expectError(GL_NO_ERROR);
1200                 ctx.endSection();
1201         }
1202
1203         ctx.glUseProgram(0);
1204 }
1205
1206 void draw_range_elements_invalid_program (NegativeTestContext& ctx)
1207 {
1208         ctx.glUseProgram(0);
1209         GLuint fbo = 0;
1210         GLfloat vertices[1];
1211
1212         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1213         ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1214         ctx.expectError(GL_INVALID_ENUM);
1215         ctx.endSection();
1216
1217         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1218         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, vertices);
1219         ctx.expectError(GL_INVALID_ENUM);
1220         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices);
1221         ctx.expectError(GL_INVALID_ENUM);
1222         ctx.endSection();
1223
1224         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1225         ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices);
1226         ctx.expectError(GL_INVALID_VALUE);
1227         ctx.endSection();
1228
1229         ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1230         ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices);
1231         ctx.expectError(GL_INVALID_VALUE);
1232         ctx.endSection();
1233
1234         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1235         ctx.glGenFramebuffers(1, &fbo);
1236         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1237         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1238         ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1239         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1240         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1241         ctx.glDeleteFramebuffers(1, &fbo);
1242         ctx.endSection();
1243 }
1244
1245 void draw_range_elements_incomplete_primitive (NegativeTestContext& ctx)
1246 {
1247         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1248         GLuint                                          fbo             = 0;
1249         GLuint                                          buf             = 0;
1250         GLuint                                          tfID    = 0;
1251         GLfloat                                         vertices[1];
1252         map<string, string>                     args;
1253         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1254         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1255
1256         ctx.glUseProgram(program.getProgram());
1257         ctx.expectError(GL_NO_ERROR);
1258
1259         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1260         ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1261         ctx.expectError(GL_INVALID_ENUM);
1262         ctx.endSection();
1263
1264         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1265         ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, -1, vertices);
1266         ctx.expectError(GL_INVALID_ENUM);
1267         ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_FLOAT, vertices);
1268         ctx.expectError(GL_INVALID_ENUM);
1269         ctx.endSection();
1270
1271         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1272         ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, -1, GL_UNSIGNED_BYTE, vertices);
1273         ctx.expectError(GL_INVALID_VALUE);
1274         ctx.endSection();
1275
1276         ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1277         ctx.glDrawRangeElements(GL_TRIANGLES, 1, 0, 1, GL_UNSIGNED_BYTE, vertices);
1278         ctx.expectError(GL_INVALID_VALUE);
1279         ctx.endSection();
1280
1281         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1282         ctx.glGenFramebuffers(1, &fbo);
1283         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1284         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1285         ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1286         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1287         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1288         ctx.glDeleteFramebuffers(1, &fbo);
1289         ctx.endSection();
1290
1291         if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
1292         {
1293                 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
1294                 const char* tfVarying = "gl_Position";
1295
1296                 ctx.glGenBuffers(1, &buf);
1297                 ctx.glGenTransformFeedbacks(1, &tfID);
1298
1299                 ctx.glUseProgram(program.getProgram());
1300                 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1301                 ctx.glLinkProgram(program.getProgram());
1302                 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1303                 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1304                 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1305                 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1306                 ctx.glBeginTransformFeedback(GL_TRIANGLES);
1307                 ctx.expectError(GL_NO_ERROR);
1308
1309                 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1310                 ctx.expectError(GL_INVALID_OPERATION);
1311
1312                 ctx.glPauseTransformFeedback();
1313                 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
1314                 ctx.expectError(GL_NO_ERROR);
1315
1316                 ctx.glEndTransformFeedback();
1317                 ctx.glDeleteBuffers(1, &buf);
1318                 ctx.glDeleteTransformFeedbacks(1, &tfID);
1319                 ctx.expectError(GL_NO_ERROR);
1320                 ctx.endSection();
1321         }
1322
1323         ctx.glUseProgram(0);
1324 }
1325
1326 void draw_range_elements_base_vertex (NegativeTestContext& ctx)
1327 {
1328         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
1329
1330         GLuint                                          fbo             = 0;
1331         GLfloat                                         vertices[1];
1332         map<string, string>                     args;
1333         args["GLSL_VERSION_STRING"]                     = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1334         glu::ShaderProgram                      program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1335
1336         ctx.glUseProgram(program.getProgram());
1337         ctx.expectError(GL_NO_ERROR);
1338
1339         ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1340         ctx.glDrawRangeElementsBaseVertex(-1, 0, 1, 1, GL_UNSIGNED_BYTE, vertices, 1);
1341         ctx.expectError(GL_INVALID_ENUM);
1342         ctx.endSection();
1343
1344         ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1345         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, -1, vertices, 1);
1346         ctx.expectError(GL_INVALID_ENUM);
1347         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_FLOAT, vertices, 1);
1348         ctx.expectError(GL_INVALID_ENUM);
1349         ctx.endSection();
1350
1351         ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1352         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, vertices, 1);
1353         ctx.expectError(GL_INVALID_VALUE);
1354         ctx.endSection();
1355
1356         ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1357         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, vertices, 1);
1358         ctx.expectError(GL_INVALID_VALUE);
1359         ctx.endSection();
1360
1361         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1362         ctx.glGenFramebuffers(1, &fbo);
1363         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1364         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1365         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices, 1);
1366         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1367         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1368         ctx.glDeleteFramebuffers(1, &fbo);
1369         ctx.endSection();
1370
1371         ctx.glUseProgram(0);
1372 }
1373
1374 void draw_range_elements_base_vertex_invalid_map (NegativeTestContext& ctx)
1375 {
1376         GLuint  buf             = 0;
1377         GLfloat vertices[1];
1378
1379         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped.");
1380         ctx.glGenBuffers(1, &buf);
1381         ctx.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf);
1382         ctx.glBufferData(GL_ELEMENT_ARRAY_BUFFER, 10, 0, GL_STATIC_DRAW);
1383         ctx.glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT);
1384         ctx.expectError(GL_NO_ERROR);
1385         ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_UNSIGNED_INT, vertices, 1);
1386         ctx.expectError(GL_INVALID_OPERATION);
1387         ctx.glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
1388         ctx.glDeleteBuffers(1, &buf);
1389         ctx.endSection();
1390 }
1391
1392 void draw_range_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
1393 {
1394         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)), "This test requires a 3.2 context or higher context version.");
1395
1396         GLfloat                                         vertices[1];
1397         map<string, string>                     args;
1398         args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1399         glu::ShaderProgram                      geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
1400
1401         ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
1402         ctx.glUseProgram(geometryProgram.getProgram());
1403         ctx.glDrawRangeElementsBaseVertex(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_INT, vertices, 1);
1404         ctx.expectError(GL_INVALID_OPERATION);
1405         ctx.endSection();
1406
1407         ctx.glUseProgram(0);
1408 }
1409
1410 std::vector<FunctionContainer> getNegativeVertexArrayApiTestFunctions ()
1411 {
1412         FunctionContainer funcs[] =
1413         {
1414                 {vertex_attribf,                                                                                                "vertex_attribf",                                                                                               "Invalid glVertexAttrib{1234}f() usage"                         },
1415                 {vertex_attribfv,                                                                                               "vertex_attribfv",                                                                                              "Invalid glVertexAttrib{1234}fv() usage"                        },
1416                 {vertex_attribi4,                                                                                               "vertex_attribi4",                                                                                              "Invalid glVertexAttribI4{i|ui}f() usage"                       },
1417                 {vertex_attribi4v,                                                                                              "vertex_attribi4v",                                                                                             "Invalid glVertexAttribI4{i|ui}fv() usage"                      },
1418                 {vertex_attrib_pointer,                                                                                 "vertex_attrib_pointer",                                                                                "Invalid glVertexAttribPointer() usage"                         },
1419                 {vertex_attrib_i_pointer,                                                                               "vertex_attrib_i_pointer",                                                                              "Invalid glVertexAttribPointer() usage"                         },
1420                 {vertex_attrib_format,                                                                                  "vertex_attrib_format",                                                                                 "Invalid glVertexAttribFormat() usage"                          },
1421                 {vertex_attrib_i_format,                                                                                "vertex_attrib_i_format",                                                                               "Invalid glVertexAttribIFormat() usage"                         },
1422                 {enable_vertex_attrib_array,                                                                    "enable_vertex_attrib_array",                                                                   "Invalid glEnableVertexAttribArray() usage"                     },
1423                 {disable_vertex_attrib_array,                                                                   "disable_vertex_attrib_array",                                                                  "Invalid glDisableVertexAttribArray() usage"            },
1424                 {gen_vertex_arrays,                                                                                             "gen_vertex_arrays",                                                                                    "Invalid glGenVertexArrays() usage"                                     },
1425                 {bind_vertex_array,                                                                                             "bind_vertex_array",                                                                                    "Invalid glBindVertexArray() usage"                                     },
1426                 {delete_vertex_arrays,                                                                                  "delete_vertex_arrays",                                                                                 "Invalid glDeleteVertexArrays() usage"                          },
1427                 {vertex_attrib_divisor,                                                                                 "vertex_attrib_divisor",                                                                                "Invalid glVertexAttribDivisor() usage"                         },
1428                 {draw_arrays,                                                                                                   "draw_arrays",                                                                                                  "Invalid glDrawArrays() usage"                                          },
1429                 {draw_arrays_invalid_program,                                                                   "draw_arrays_invalid_program",                                                                  "Invalid glDrawArrays() usage"                                          },
1430                 {draw_arrays_incomplete_primitive,                                                              "draw_arrays_incomplete_primitive",                                                             "Invalid glDrawArrays() usage"                                          },
1431                 {draw_elements,                                                                                                 "draw_elements",                                                                                                "Invalid glDrawElements() usage"                                        },
1432                 {draw_elements_base_vertex,                                                                             "draw_elements_base_vertex",                                                                    "Invalid glDrawElementsBaseVertex() usage"                      },
1433                 {draw_elements_base_vertex_invalid_map,                                                 "draw_elements_base_vertex_invalid_map" ,                                               "Invalid glDrawElementsBaseVertex() usage"                      },
1434                 {draw_elements_base_vertex_primitive_mode_mismatch,                             "draw_elements_base_vertex_primitive_mode_mismatch",                    "Invalid glDrawElementsBaseVertex() usage"                      },
1435                 {draw_elements_invalid_program,                                                                 "draw_elements_invalid_program",                                                                "Invalid glDrawElements() usage"                                        },
1436                 {draw_elements_incomplete_primitive,                                                    "draw_elements_incomplete_primitive",                                                   "Invalid glDrawElements() usage"                                        },
1437                 {draw_arrays_instanced,                                                                                 "draw_arrays_instanced",                                                                                "Invalid glDrawArraysInstanced() usage"                         },
1438                 {draw_arrays_instanced_invalid_program,                                                 "draw_arrays_instanced_invalid_program",                                                "Invalid glDrawArraysInstanced() usage"                         },
1439                 {draw_arrays_instanced_incomplete_primitive,                                    "draw_arrays_instanced_incomplete_primitive",                                   "Invalid glDrawArraysInstanced() usage"                         },
1440                 {draw_elements_instanced,                                                                               "draw_elements_instanced",                                                                              "Invalid glDrawElementsInstanced() usage"                       },
1441                 {draw_elements_instanced_invalid_program,                                               "draw_elements_instanced_invalid_program",                                              "Invalid glDrawElementsInstanced() usage"                       },
1442                 {draw_elements_instanced_incomplete_primitive,                                  "draw_elements_instanced_incomplete_primitive",                                 "Invalid glDrawElementsInstanced() usage"                       },
1443                 {draw_elements_instanced_base_vertex,                                                   "draw_elements_instanced_base_vertex",                                                  "Invalid glDrawElementsInstancedBaseVertex() usage"     },
1444                 {draw_elements_instanced_base_vertex_invalid_map,                               "draw_elements_instanced_base_vertex_invalid_map",                              "Invalid glDrawElementsInstancedBaseVertex() usage"     },
1445                 {draw_elements_instanced_base_vertex_primitive_mode_mismatch,   "draw_elements_instanced_base_vertex_primitive_mode_mismatch",  "Invalid glDrawElementsInstancedBaseVertex() usage"     },
1446                 {draw_range_elements,                                                                                   "draw_range_elements",                                                                                  "Invalid glDrawRangeElements() usage"                           },
1447                 {draw_range_elements_invalid_program,                                                   "draw_range_elements_invalid_program",                                                  "Invalid glDrawRangeElements() usage"                           },
1448                 {draw_range_elements_incomplete_primitive,                                              "draw_range_elements_incomplete_primitive",                                             "Invalid glDrawRangeElements() usage"                           },
1449                 {draw_range_elements_base_vertex,                                                               "draw_range_elements_base_vertex",                                                              "Invalid glDrawRangeElementsBaseVertex() usage"         },
1450                 {draw_range_elements_base_vertex_invalid_map,                                   "draw_range_elements_base_vertex_invalid_map",                                  "Invalid glDrawRangeElementsBaseVertex() usage"         },
1451                 {draw_range_elements_base_vertex_primitive_mode_mismatch,               "draw_range_elements_base_vertex_primitive_mode_mismatch",              "Invalid glDrawRangeElementsBaseVertex() usage"         },
1452         };
1453
1454         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
1455 }
1456
1457 } // NegativeTestShared
1458 } // Functional
1459 } // gles31
1460 } // deqp