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