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
vertex_attribf(NegativeTestContext & ctx)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
vertex_attribfv(NegativeTestContext & ctx)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
vertex_attribi4(NegativeTestContext & ctx)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
vertex_attribi4v(NegativeTestContext & ctx)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
vertex_attrib_pointer(NegativeTestContext & ctx)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
vertex_attrib_i_pointer(NegativeTestContext & ctx)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
vertex_attrib_format(NegativeTestContext & ctx)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
vertex_attrib_i_format(NegativeTestContext & ctx)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
enable_vertex_attrib_array(NegativeTestContext & ctx)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
disable_vertex_attrib_array(NegativeTestContext & ctx)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
gen_vertex_arrays(NegativeTestContext & ctx)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
bind_vertex_array(NegativeTestContext & ctx)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
delete_vertex_arrays(NegativeTestContext & ctx)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
vertex_attrib_divisor(NegativeTestContext & ctx)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
draw_arrays(NegativeTestContext & ctx)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
draw_arrays_invalid_program(NegativeTestContext & ctx)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
draw_arrays_incomplete_primitive(NegativeTestContext & ctx)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
draw_elements(NegativeTestContext & ctx)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 GLbyte indices[1] = {0};
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, indices);
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, indices);
504 ctx.expectError(GL_INVALID_ENUM);
505 ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, indices);
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, indices);
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, indices);
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, indices);
543 ctx.expectError(GL_INVALID_OPERATION);
544
545 ctx.glPauseTransformFeedback();
546 ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices);
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
draw_elements_invalid_program(NegativeTestContext & ctx)559 void draw_elements_invalid_program (NegativeTestContext& ctx)
560 {
561 ctx.glUseProgram(0);
562 GLuint fbo = 0;
563 GLbyte indices[1] = {0};
564
565 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
566 ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, indices);
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, indices);
572 ctx.expectError(GL_INVALID_ENUM);
573 ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, indices);
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, indices);
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, indices);
587 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
588 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
589 ctx.glDeleteFramebuffers(1, &fbo);
590 ctx.endSection();
591 }
592
draw_elements_incomplete_primitive(NegativeTestContext & ctx)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 GLbyte indices[1] = {0};
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, indices);
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, indices);
614 ctx.expectError(GL_INVALID_ENUM);
615 ctx.glDrawElements(GL_TRIANGLES, 1, GL_FLOAT, indices);
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, indices);
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, indices);
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, indices);
653 ctx.expectError(GL_INVALID_OPERATION);
654
655 ctx.glPauseTransformFeedback();
656 ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices);
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
draw_elements_base_vertex(NegativeTestContext & ctx)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 GLuint indices[1] = {0};
675
676 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
677 ctx.glDrawElementsBaseVertex(-1, 1, GL_UNSIGNED_INT, indices, 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, indices, 1);
683 ctx.expectError(GL_INVALID_ENUM);
684 ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_FLOAT, indices, 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, indices, 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, indices, 1);
698 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
699 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
700 ctx.glDeleteFramebuffers(1, &fbo);
701 ctx.endSection();
702 }
703
draw_elements_base_vertex_primitive_mode_mismatch(NegativeTestContext & ctx)704 void draw_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
705 {
706 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.");
707
708 GLuint indices[1] = {0};
709 map<string, string> args;
710 args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
711
712 glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
713
714 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.");
715 ctx.glUseProgram(program.getProgram());
716 ctx.glDrawElementsBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, indices, 1);
717 ctx.expectError(GL_INVALID_OPERATION);
718 ctx.endSection();
719
720 ctx.glUseProgram(0);
721 }
722
draw_arrays_instanced(NegativeTestContext & ctx)723 void draw_arrays_instanced (NegativeTestContext& ctx)
724 {
725 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
726 GLuint fbo = 0;
727 map<string, string> args;
728 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
729 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
730
731 ctx.glUseProgram(program.getProgram());
732 ctx.expectError(GL_NO_ERROR);
733 ctx.glVertexAttribDivisor(0, 1);
734 ctx.expectError(GL_NO_ERROR);
735
736 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
737 ctx.glDrawArraysInstanced(-1, 0, 1, 1);
738 ctx.expectError(GL_INVALID_ENUM);
739 ctx.endSection();
740
741 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
742 ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
743 ctx.expectError(GL_INVALID_VALUE);
744 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
745 ctx.expectError(GL_INVALID_VALUE);
746 ctx.endSection();
747
748 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
749 ctx.glGenFramebuffers(1, &fbo);
750 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
751 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
752 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
753 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
754 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
755 ctx.glDeleteFramebuffers(1, &fbo);
756 ctx.endSection();
757
758 ctx.glUseProgram(0);
759 }
760
draw_arrays_instanced_invalid_program(NegativeTestContext & ctx)761 void draw_arrays_instanced_invalid_program (NegativeTestContext& ctx)
762 {
763 ctx.glUseProgram(0);
764 GLuint fbo = 0;
765 ctx.glVertexAttribDivisor(0, 1);
766 ctx.expectError(GL_NO_ERROR);
767
768 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
769 ctx.glDrawArraysInstanced(-1, 0, 1, 1);
770 ctx.expectError(GL_INVALID_ENUM);
771 ctx.endSection();
772
773 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
774 ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
775 ctx.expectError(GL_INVALID_VALUE);
776 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
777 ctx.expectError(GL_INVALID_VALUE);
778 ctx.endSection();
779
780 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
781 ctx.glGenFramebuffers(1, &fbo);
782 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
783 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
784 ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
785 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
786 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
787 ctx.glDeleteFramebuffers(1, &fbo);
788 ctx.endSection();
789 }
790
draw_arrays_instanced_incomplete_primitive(NegativeTestContext & ctx)791 void draw_arrays_instanced_incomplete_primitive (NegativeTestContext& ctx)
792 {
793 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
794 GLuint fbo = 0;
795 map<string, string> args;
796 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
797 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
798
799 ctx.glVertexAttribDivisor(0, 1);
800 ctx.expectError(GL_NO_ERROR);
801
802 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
803 ctx.glDrawArraysInstanced(-1, 0, 1, 1);
804 ctx.expectError(GL_INVALID_ENUM);
805 ctx.endSection();
806
807 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
808 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, -1, 1);
809 ctx.expectError(GL_INVALID_VALUE);
810 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, -1);
811 ctx.expectError(GL_INVALID_VALUE);
812 ctx.endSection();
813
814 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
815 ctx.glGenFramebuffers(1, &fbo);
816 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
817 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
818 ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, 1);
819 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
820 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
821 ctx.glDeleteFramebuffers(1, &fbo);
822 ctx.endSection();
823
824 ctx.glUseProgram(0);
825 }
826
draw_elements_instanced(NegativeTestContext & ctx)827 void draw_elements_instanced (NegativeTestContext& ctx)
828 {
829 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
830 GLuint fbo = 0;
831 GLuint buf = 0;
832 GLuint tfID = 0;
833 GLbyte indices[1] = {0};
834 map<string, string> args;
835 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
836 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
837
838 ctx.glUseProgram(program.getProgram());
839 ctx.glVertexAttribDivisor(0, 1);
840 ctx.expectError(GL_NO_ERROR);
841
842 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
843 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
844 ctx.expectError(GL_INVALID_ENUM);
845 ctx.endSection();
846
847 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
848 ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, indices, 1);
849 ctx.expectError(GL_INVALID_ENUM);
850 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, indices, 1);
851 ctx.expectError(GL_INVALID_ENUM);
852 ctx.endSection();
853
854 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
855 ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1);
856 ctx.expectError(GL_INVALID_VALUE);
857 ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1);
858 ctx.expectError(GL_INVALID_VALUE);
859 ctx.endSection();
860
861 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
862 ctx.glGenFramebuffers(1, &fbo);
863 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
864 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
865 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
866 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
867 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
868 ctx.glDeleteFramebuffers(1, &fbo);
869 ctx.endSection();
870
871 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
872 {
873 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
874 const char* tfVarying = "gl_Position";
875
876 ctx.glGenBuffers(1, &buf);
877 ctx.glGenTransformFeedbacks(1, &tfID);
878
879 ctx.glUseProgram(program.getProgram());
880 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
881 ctx.glLinkProgram(program.getProgram());
882 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
883 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
884 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
885 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
886 ctx.glBeginTransformFeedback(GL_POINTS);
887 ctx.expectError(GL_NO_ERROR);
888
889 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
890 ctx.expectError(GL_INVALID_OPERATION);
891
892 ctx.glPauseTransformFeedback();
893 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
894 ctx.expectError(GL_NO_ERROR);
895
896 ctx.glEndTransformFeedback();
897 ctx.glDeleteBuffers(1, &buf);
898 ctx.glDeleteTransformFeedbacks(1, &tfID);
899 ctx.expectError(GL_NO_ERROR);
900 ctx.endSection();
901 }
902
903 ctx.glUseProgram(0);
904 }
905
draw_elements_instanced_invalid_program(NegativeTestContext & ctx)906 void draw_elements_instanced_invalid_program (NegativeTestContext& ctx)
907 {
908 ctx.glUseProgram(0);
909 GLuint fbo = 0;
910 GLbyte indices[1] = {0};
911 ctx.glVertexAttribDivisor(0, 1);
912 ctx.expectError(GL_NO_ERROR);
913
914 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
915 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
916 ctx.expectError(GL_INVALID_ENUM);
917 ctx.endSection();
918
919 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
920 ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, indices, 1);
921 ctx.expectError(GL_INVALID_ENUM);
922 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, indices, 1);
923 ctx.expectError(GL_INVALID_ENUM);
924 ctx.endSection();
925
926 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
927 ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1);
928 ctx.expectError(GL_INVALID_VALUE);
929 ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1);
930 ctx.expectError(GL_INVALID_VALUE);
931 ctx.endSection();
932
933 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
934 ctx.glGenFramebuffers(1, &fbo);
935 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
936 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
937 ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
938 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
939 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
940 ctx.glDeleteFramebuffers(1, &fbo);
941 ctx.endSection();
942 }
943
draw_elements_instanced_incomplete_primitive(NegativeTestContext & ctx)944 void draw_elements_instanced_incomplete_primitive (NegativeTestContext& ctx)
945 {
946 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
947 GLuint fbo = 0;
948 GLuint buf = 0;
949 GLuint tfID = 0;
950 GLbyte indices[1] = {0};
951 map<string, string> args;
952 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
953 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
954
955 ctx.glUseProgram(program.getProgram());
956 ctx.glVertexAttribDivisor(0, 1);
957 ctx.expectError(GL_NO_ERROR);
958
959 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
960 ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
961 ctx.expectError(GL_INVALID_ENUM);
962 ctx.endSection();
963
964 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
965 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, -1, indices, 1);
966 ctx.expectError(GL_INVALID_ENUM);
967 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_FLOAT, indices, 1);
968 ctx.expectError(GL_INVALID_ENUM);
969 ctx.endSection();
970
971 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
972 ctx.glDrawElementsInstanced(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, indices, 1);
973 ctx.expectError(GL_INVALID_VALUE);
974 ctx.glDrawElementsInstanced(GL_TRIANGLES, 11, GL_UNSIGNED_BYTE, indices, -1);
975 ctx.expectError(GL_INVALID_VALUE);
976 ctx.endSection();
977
978 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
979 ctx.glGenFramebuffers(1, &fbo);
980 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
981 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
982 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
983 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
984 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
985 ctx.glDeleteFramebuffers(1, &fbo);
986 ctx.endSection();
987
988 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
989 {
990 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
991 const char* tfVarying= "gl_Position";
992
993 ctx.glGenBuffers(1, &buf);
994 ctx.glGenTransformFeedbacks(1, &tfID);
995
996 ctx.glUseProgram(program.getProgram());
997 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
998 ctx.glLinkProgram(program.getProgram());
999 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1000 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1001 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1002 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1003 ctx.glBeginTransformFeedback(GL_TRIANGLES);
1004 ctx.expectError(GL_NO_ERROR);
1005
1006 ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
1007 ctx.expectError(GL_INVALID_OPERATION);
1008
1009 ctx.glPauseTransformFeedback();
1010 ctx.glDrawElementsInstanced (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
1011 ctx.expectError(GL_NO_ERROR);
1012
1013 ctx.glEndTransformFeedback();
1014 ctx.glDeleteBuffers(1, &buf);
1015 ctx.glDeleteTransformFeedbacks(1, &tfID);
1016 ctx.expectError(GL_NO_ERROR);
1017 ctx.endSection();
1018 }
1019
1020 ctx.glUseProgram(0);
1021 }
1022
draw_elements_instanced_base_vertex(NegativeTestContext & ctx)1023 void draw_elements_instanced_base_vertex (NegativeTestContext& ctx)
1024 {
1025 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.");
1026
1027 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1028 GLuint fbo = 0;
1029 GLbyte indices[1] = {0};
1030 map<string, string> args;
1031 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1032 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1033
1034 ctx.glUseProgram(program.getProgram());
1035 ctx.glVertexAttribDivisor(0, 1);
1036 ctx.expectError(GL_NO_ERROR);
1037
1038 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1039 ctx.glDrawElementsInstancedBaseVertex(-1, 1, GL_UNSIGNED_BYTE, indices, 1, 1);
1040 ctx.expectError(GL_INVALID_ENUM);
1041 ctx.endSection();
1042
1043 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1044 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, -1, indices, 1, 1);
1045 ctx.expectError(GL_INVALID_ENUM);
1046 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_FLOAT, indices, 1, 1);
1047 ctx.expectError(GL_INVALID_ENUM);
1048 ctx.endSection();
1049
1050 ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
1051 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1, 1);
1052 ctx.expectError(GL_INVALID_VALUE);
1053 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1, 1);
1054 ctx.expectError(GL_INVALID_VALUE);
1055 ctx.endSection();
1056
1057 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1058 ctx.glGenFramebuffers(1, &fbo);
1059 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1060 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1061 ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1, 1);
1062 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1063 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1064 ctx.glDeleteFramebuffers(1, &fbo);
1065 ctx.endSection();
1066
1067 ctx.glUseProgram(0);
1068 }
1069
draw_elements_instanced_base_vertex_primitive_mode_mismatch(NegativeTestContext & ctx)1070 void draw_elements_instanced_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
1071 {
1072 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.");
1073
1074 GLuint indices[1] = {0};
1075 map<string, string> args;
1076 args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1077 glu::ShaderProgram geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
1078
1079 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.");
1080 ctx.glUseProgram(geometryProgram.getProgram());
1081 ctx.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, indices, 1, 1);
1082 ctx.expectError(GL_INVALID_OPERATION);
1083 ctx.endSection();
1084
1085 ctx.glUseProgram(0);
1086 }
1087
draw_range_elements(NegativeTestContext & ctx)1088 void draw_range_elements (NegativeTestContext& ctx)
1089 {
1090 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1091 GLuint fbo = 0;
1092 GLuint buf = 0;
1093 GLuint tfID = 0;
1094 GLbyte indices[1] = {0};
1095 map<string, string> args;
1096 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1097 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1098
1099 ctx.glUseProgram(program.getProgram());
1100 ctx.expectError(GL_NO_ERROR);
1101
1102 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1103 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1104 ctx.expectError(GL_INVALID_ENUM);
1105 ctx.endSection();
1106
1107 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1108 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, indices);
1109 ctx.expectError(GL_INVALID_ENUM);
1110 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, indices);
1111 ctx.expectError(GL_INVALID_ENUM);
1112 ctx.endSection();
1113
1114 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1115 ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
1116 ctx.expectError(GL_INVALID_VALUE);
1117 ctx.endSection();
1118
1119 ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1120 ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
1121 ctx.expectError(GL_INVALID_VALUE);
1122 ctx.endSection();
1123
1124 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1125 ctx.glGenFramebuffers(1, &fbo);
1126 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1127 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1128 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1129 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1130 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1131 ctx.glDeleteFramebuffers(1, &fbo);
1132 ctx.endSection();
1133
1134 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
1135 {
1136 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
1137 const char* tfVarying= "gl_Position";
1138
1139 ctx.glGenBuffers(1, &buf);
1140 ctx.glGenTransformFeedbacks(1, &tfID);
1141
1142 ctx.glUseProgram(program.getProgram());
1143 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1144 ctx.glLinkProgram(program.getProgram());
1145 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1146 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1147 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1148 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1149 ctx.glBeginTransformFeedback(GL_POINTS);
1150 ctx.expectError(GL_NO_ERROR);
1151
1152 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1153 ctx.expectError(GL_INVALID_OPERATION);
1154
1155 ctx.glPauseTransformFeedback();
1156 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1157 ctx.expectError(GL_NO_ERROR);
1158
1159 ctx.glEndTransformFeedback();
1160 ctx.glDeleteBuffers(1, &buf);
1161 ctx.glDeleteTransformFeedbacks(1, &tfID);
1162 ctx.expectError(GL_NO_ERROR);
1163 ctx.endSection();
1164 }
1165
1166 ctx.glUseProgram(0);
1167 }
1168
draw_range_elements_invalid_program(NegativeTestContext & ctx)1169 void draw_range_elements_invalid_program (NegativeTestContext& ctx)
1170 {
1171 ctx.glUseProgram(0);
1172 GLuint fbo = 0;
1173 GLbyte indices[1] = {0};
1174
1175 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1176 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1177 ctx.expectError(GL_INVALID_ENUM);
1178 ctx.endSection();
1179
1180 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1181 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, indices);
1182 ctx.expectError(GL_INVALID_ENUM);
1183 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, indices);
1184 ctx.expectError(GL_INVALID_ENUM);
1185 ctx.endSection();
1186
1187 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1188 ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
1189 ctx.expectError(GL_INVALID_VALUE);
1190 ctx.endSection();
1191
1192 ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1193 ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
1194 ctx.expectError(GL_INVALID_VALUE);
1195 ctx.endSection();
1196
1197 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1198 ctx.glGenFramebuffers(1, &fbo);
1199 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1200 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1201 ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1202 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1203 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1204 ctx.glDeleteFramebuffers(1, &fbo);
1205 ctx.endSection();
1206 }
1207
draw_range_elements_incomplete_primitive(NegativeTestContext & ctx)1208 void draw_range_elements_incomplete_primitive (NegativeTestContext& ctx)
1209 {
1210 const bool isES32 = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
1211 GLuint fbo = 0;
1212 GLuint buf = 0;
1213 GLuint tfID = 0;
1214 GLbyte indices[1] = {0};
1215 map<string, string> args;
1216 args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
1217 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1218
1219 ctx.glUseProgram(program.getProgram());
1220 ctx.expectError(GL_NO_ERROR);
1221
1222 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1223 ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1224 ctx.expectError(GL_INVALID_ENUM);
1225 ctx.endSection();
1226
1227 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1228 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, -1, indices);
1229 ctx.expectError(GL_INVALID_ENUM);
1230 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_FLOAT, indices);
1231 ctx.expectError(GL_INVALID_ENUM);
1232 ctx.endSection();
1233
1234 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1235 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
1236 ctx.expectError(GL_INVALID_VALUE);
1237 ctx.endSection();
1238
1239 ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1240 ctx.glDrawRangeElements(GL_TRIANGLES, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
1241 ctx.expectError(GL_INVALID_VALUE);
1242 ctx.endSection();
1243
1244 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1245 ctx.glGenFramebuffers(1, &fbo);
1246 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1247 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1248 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1249 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1250 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1251 ctx.glDeleteFramebuffers(1, &fbo);
1252 ctx.endSection();
1253
1254 if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
1255 {
1256 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
1257 const char* tfVarying = "gl_Position";
1258
1259 ctx.glGenBuffers(1, &buf);
1260 ctx.glGenTransformFeedbacks(1, &tfID);
1261
1262 ctx.glUseProgram(program.getProgram());
1263 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1264 ctx.glLinkProgram(program.getProgram());
1265 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
1266 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1267 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1268 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1269 ctx.glBeginTransformFeedback(GL_TRIANGLES);
1270 ctx.expectError(GL_NO_ERROR);
1271
1272 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1273 ctx.expectError(GL_INVALID_OPERATION);
1274
1275 ctx.glPauseTransformFeedback();
1276 ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
1277 ctx.expectError(GL_NO_ERROR);
1278
1279 ctx.glEndTransformFeedback();
1280 ctx.glDeleteBuffers(1, &buf);
1281 ctx.glDeleteTransformFeedbacks(1, &tfID);
1282 ctx.expectError(GL_NO_ERROR);
1283 ctx.endSection();
1284 }
1285
1286 ctx.glUseProgram(0);
1287 }
1288
draw_range_elements_base_vertex(NegativeTestContext & ctx)1289 void draw_range_elements_base_vertex (NegativeTestContext& ctx)
1290 {
1291 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.");
1292
1293 GLuint fbo = 0;
1294 GLbyte indices[1] = {0};
1295 map<string, string> args;
1296 args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1297 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
1298
1299 ctx.glUseProgram(program.getProgram());
1300 ctx.expectError(GL_NO_ERROR);
1301
1302 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
1303 ctx.glDrawRangeElementsBaseVertex(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices, 1);
1304 ctx.expectError(GL_INVALID_ENUM);
1305 ctx.endSection();
1306
1307 ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
1308 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, -1, indices, 1);
1309 ctx.expectError(GL_INVALID_ENUM);
1310 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_FLOAT, indices, 1);
1311 ctx.expectError(GL_INVALID_ENUM);
1312 ctx.endSection();
1313
1314 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
1315 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices, 1);
1316 ctx.expectError(GL_INVALID_VALUE);
1317 ctx.endSection();
1318
1319 ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
1320 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices, 1);
1321 ctx.expectError(GL_INVALID_VALUE);
1322 ctx.endSection();
1323
1324 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1325 ctx.glGenFramebuffers(1, &fbo);
1326 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1327 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1328 ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices, 1);
1329 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1330 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1331 ctx.glDeleteFramebuffers(1, &fbo);
1332 ctx.endSection();
1333
1334 ctx.glUseProgram(0);
1335 }
1336
draw_range_elements_base_vertex_primitive_mode_mismatch(NegativeTestContext & ctx)1337 void draw_range_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
1338 {
1339 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.");
1340
1341 GLuint indices[1] = {0};
1342 map<string, string> args;
1343 args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
1344 glu::ShaderProgram geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
1345
1346 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.");
1347 ctx.glUseProgram(geometryProgram.getProgram());
1348 ctx.glDrawRangeElementsBaseVertex(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_INT, indices, 1);
1349 ctx.expectError(GL_INVALID_OPERATION);
1350 ctx.endSection();
1351
1352 ctx.glUseProgram(0);
1353 }
1354
getNegativeVertexArrayApiTestFunctions()1355 std::vector<FunctionContainer> getNegativeVertexArrayApiTestFunctions ()
1356 {
1357 FunctionContainer funcs[] =
1358 {
1359 {vertex_attribf, "vertex_attribf", "Invalid glVertexAttrib{1234}f() usage" },
1360 {vertex_attribfv, "vertex_attribfv", "Invalid glVertexAttrib{1234}fv() usage" },
1361 {vertex_attribi4, "vertex_attribi4", "Invalid glVertexAttribI4{i|ui}f() usage" },
1362 {vertex_attribi4v, "vertex_attribi4v", "Invalid glVertexAttribI4{i|ui}fv() usage" },
1363 {vertex_attrib_pointer, "vertex_attrib_pointer", "Invalid glVertexAttribPointer() usage" },
1364 {vertex_attrib_i_pointer, "vertex_attrib_i_pointer", "Invalid glVertexAttribPointer() usage" },
1365 {vertex_attrib_format, "vertex_attrib_format", "Invalid glVertexAttribFormat() usage" },
1366 {vertex_attrib_i_format, "vertex_attrib_i_format", "Invalid glVertexAttribIFormat() usage" },
1367 {enable_vertex_attrib_array, "enable_vertex_attrib_array", "Invalid glEnableVertexAttribArray() usage" },
1368 {disable_vertex_attrib_array, "disable_vertex_attrib_array", "Invalid glDisableVertexAttribArray() usage" },
1369 {gen_vertex_arrays, "gen_vertex_arrays", "Invalid glGenVertexArrays() usage" },
1370 {bind_vertex_array, "bind_vertex_array", "Invalid glBindVertexArray() usage" },
1371 {delete_vertex_arrays, "delete_vertex_arrays", "Invalid glDeleteVertexArrays() usage" },
1372 {vertex_attrib_divisor, "vertex_attrib_divisor", "Invalid glVertexAttribDivisor() usage" },
1373 {draw_arrays, "draw_arrays", "Invalid glDrawArrays() usage" },
1374 {draw_arrays_invalid_program, "draw_arrays_invalid_program", "Invalid glDrawArrays() usage" },
1375 {draw_arrays_incomplete_primitive, "draw_arrays_incomplete_primitive", "Invalid glDrawArrays() usage" },
1376 {draw_elements, "draw_elements", "Invalid glDrawElements() usage" },
1377 {draw_elements_base_vertex, "draw_elements_base_vertex", "Invalid glDrawElementsBaseVertex() usage" },
1378 {draw_elements_base_vertex_primitive_mode_mismatch, "draw_elements_base_vertex_primitive_mode_mismatch", "Invalid glDrawElementsBaseVertex() usage" },
1379 {draw_elements_invalid_program, "draw_elements_invalid_program", "Invalid glDrawElements() usage" },
1380 {draw_elements_incomplete_primitive, "draw_elements_incomplete_primitive", "Invalid glDrawElements() usage" },
1381 {draw_arrays_instanced, "draw_arrays_instanced", "Invalid glDrawArraysInstanced() usage" },
1382 {draw_arrays_instanced_invalid_program, "draw_arrays_instanced_invalid_program", "Invalid glDrawArraysInstanced() usage" },
1383 {draw_arrays_instanced_incomplete_primitive, "draw_arrays_instanced_incomplete_primitive", "Invalid glDrawArraysInstanced() usage" },
1384 {draw_elements_instanced, "draw_elements_instanced", "Invalid glDrawElementsInstanced() usage" },
1385 {draw_elements_instanced_invalid_program, "draw_elements_instanced_invalid_program", "Invalid glDrawElementsInstanced() usage" },
1386 {draw_elements_instanced_incomplete_primitive, "draw_elements_instanced_incomplete_primitive", "Invalid glDrawElementsInstanced() usage" },
1387 {draw_elements_instanced_base_vertex, "draw_elements_instanced_base_vertex", "Invalid glDrawElementsInstancedBaseVertex() usage" },
1388 {draw_elements_instanced_base_vertex_primitive_mode_mismatch, "draw_elements_instanced_base_vertex_primitive_mode_mismatch", "Invalid glDrawElementsInstancedBaseVertex() usage" },
1389 {draw_range_elements, "draw_range_elements", "Invalid glDrawRangeElements() usage" },
1390 {draw_range_elements_invalid_program, "draw_range_elements_invalid_program", "Invalid glDrawRangeElements() usage" },
1391 {draw_range_elements_incomplete_primitive, "draw_range_elements_incomplete_primitive", "Invalid glDrawRangeElements() usage" },
1392 {draw_range_elements_base_vertex, "draw_range_elements_base_vertex", "Invalid glDrawRangeElementsBaseVertex() usage" },
1393 {draw_range_elements_base_vertex_primitive_mode_mismatch, "draw_range_elements_base_vertex_primitive_mode_mismatch", "Invalid glDrawRangeElementsBaseVertex() usage" },
1394 };
1395
1396 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
1397 }
1398
1399 } // NegativeTestShared
1400 } // Functional
1401 } // gles31
1402 } // deqp
1403