1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Negative Shader API tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fNegativeShaderApiTests.hpp"
25 #include "es3fApiCase.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "gluContextInfo.hpp"
28 #include "deUniquePtr.hpp"
29
30 #include "glwDefs.hpp"
31 #include "glwEnums.hpp"
32
33 using namespace glw; // GL types
34
35 namespace deqp
36 {
37 namespace gles3
38 {
39 namespace Functional
40 {
41
42 using tcu::TestLog;
43
44 static const char* vertexShaderSource = "#version 300 es\n"
45 "void main (void)\n"
46 "{\n"
47 " gl_Position = vec4(0.0);\n"
48 "}\n\0";
49
50 static const char* fragmentShaderSource = "#version 300 es\n"
51 "layout(location = 0) out mediump vec4 fragColor;"
52 "void main (void)\n"
53 "{\n"
54 " fragColor = vec4(0.0);\n"
55 "}\n\0";
56
57 static const char* uniformTestVertSource = "#version 300 es\n"
58 "uniform mediump vec4 vec4_v;\n"
59 "uniform mediump mat4 mat4_v;\n"
60 "void main (void)\n"
61 "{\n"
62 " gl_Position = mat4_v * vec4_v;\n"
63 "}\n\0";
64
65 static const char* uniformTestFragSource = "#version 300 es\n"
66 "uniform mediump ivec4 ivec4_f;\n"
67 "uniform mediump uvec4 uvec4_f;\n"
68 "uniform sampler2D sampler_f;\n"
69 "layout(location = 0) out mediump vec4 fragColor;"
70 "void main (void)\n"
71 "{\n"
72 " fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n"
73 " fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n"
74 "}\n\0";
75
76 static const char* uniformBlockVertSource = "#version 300 es\n"
77 "layout(shared) uniform Block { lowp float var; };\n"
78 "void main (void)\n"
79 "{\n"
80 " gl_Position = vec4(var);\n"
81 "}\n\0";
82
NegativeShaderApiTests(Context & context)83 NegativeShaderApiTests::NegativeShaderApiTests (Context& context)
84 : TestCaseGroup(context, "shader", "Negative Shader API Cases")
85 {
86 }
87
~NegativeShaderApiTests(void)88 NegativeShaderApiTests::~NegativeShaderApiTests (void)
89 {
90 }
91
init(void)92 void NegativeShaderApiTests::init (void)
93 {
94 // Shader control commands
95
96 ES3F_ADD_API_CASE(create_shader, "Invalid glCreateShader() usage",
97 {
98 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
99 glCreateShader(-1);
100 expectError(GL_INVALID_ENUM);
101 m_log << TestLog::EndSection;
102 });
103 ES3F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage",
104 {
105 // \note Shader compilation must be supported.
106
107 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
108 glShaderSource(1, 0, 0, 0);
109 expectError(GL_INVALID_VALUE);
110 m_log << TestLog::EndSection;
111
112 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if count is less than 0.");
113 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
114 glShaderSource(shader, -1, 0, 0);
115 expectError(GL_INVALID_VALUE);
116 m_log << TestLog::EndSection;
117
118 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
119 GLuint program = glCreateProgram();
120 glShaderSource(program, 0, 0, 0);
121 expectError(GL_INVALID_OPERATION);
122 m_log << TestLog::EndSection;
123
124 glDeleteProgram(program);
125 glDeleteShader(shader);
126 });
127 ES3F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage",
128 {
129 // \note Shader compilation must be supported.
130
131 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
132 glCompileShader(9);
133 expectError(GL_INVALID_VALUE);
134 m_log << TestLog::EndSection;
135
136 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
137 GLuint program = glCreateProgram();
138 glCompileShader(program);
139 expectError(GL_INVALID_OPERATION);
140 m_log << TestLog::EndSection;
141
142 glDeleteProgram(program);
143 });
144 ES3F_ADD_API_CASE(delete_shader, "Invalid glDeleteShader() usage",
145 {
146 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
147 glDeleteShader(9);
148 expectError(GL_INVALID_VALUE);
149 m_log << TestLog::EndSection;
150 });
151 ES3F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage",
152 {
153 std::vector<deInt32> binaryFormats;
154 getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
155 deBool shaderBinarySupported = !binaryFormats.empty();
156 if (!shaderBinarySupported)
157 m_log << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
158 else
159 m_log << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
160
161 GLuint shaders[2];
162 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
163 shaders[1] = glCreateShader(GL_VERTEX_SHADER);
164
165 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryFormat is not an accepted value.");
166 glShaderBinary(1, &shaders[0], -1, 0, 0);
167 expectError(GL_INVALID_ENUM);
168 m_log << TestLog::EndSection;
169
170 if (shaderBinarySupported)
171 {
172 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if the data pointed to by binary does not match the format specified by binaryFormat.");
173 const GLbyte data = 0x005F;
174 glShaderBinary(1, &shaders[0], binaryFormats[0], &data, 1);
175 expectError(GL_INVALID_VALUE);
176 m_log << TestLog::EndSection;
177
178 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if more than one of the handles in shaders refers to the same type of shader, or GL_INVALID_VALUE due to invalid data pointer.");
179 glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0);
180 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
181 m_log << TestLog::EndSection;
182 }
183
184 glDeleteShader(shaders[0]);
185 glDeleteShader(shaders[1]);
186 });
187 ES3F_ADD_API_CASE(attach_shader, "Invalid glAttachShader() usage",
188 {
189 GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
190 GLuint shader2 = glCreateShader(GL_VERTEX_SHADER);
191 GLuint program = glCreateProgram();
192
193 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
194 glAttachShader(shader1, shader1);
195 expectError(GL_INVALID_OPERATION);
196 m_log << TestLog::EndSection;
197
198 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
199 glAttachShader(program, program);
200 expectError(GL_INVALID_OPERATION);
201 glAttachShader(shader1, program);
202 expectError(GL_INVALID_OPERATION);
203 m_log << TestLog::EndSection;
204
205 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
206 glAttachShader(program, -1);
207 expectError(GL_INVALID_VALUE);
208 glAttachShader(-1, shader1);
209 expectError(GL_INVALID_VALUE);
210 glAttachShader(-1, -1);
211 expectError(GL_INVALID_VALUE);
212 m_log << TestLog::EndSection;
213
214 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is already attached to program.");
215 glAttachShader(program, shader1);
216 expectError(GL_NO_ERROR);
217 glAttachShader(program, shader1);
218 expectError(GL_INVALID_OPERATION);
219 m_log << TestLog::EndSection;
220
221 if (glu::isContextTypeES(m_context.getRenderContext().getType())){
222 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader of the same type as shader is already attached to program.");
223 glAttachShader(program, shader2);
224 expectError(GL_INVALID_OPERATION);
225 m_log << TestLog::EndSection;
226 }
227
228 glDeleteProgram(program);
229 glDeleteShader(shader1);
230 glDeleteShader(shader2);
231 });
232 ES3F_ADD_API_CASE(detach_shader, "Invalid glDetachShader() usage",
233 {
234 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
235 GLuint program = glCreateProgram();
236
237 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
238 glDetachShader(-1, shader);
239 expectError(GL_INVALID_VALUE);
240 glDetachShader(program, -1);
241 expectError(GL_INVALID_VALUE);
242 glDetachShader(-1, -1);
243 expectError(GL_INVALID_VALUE);
244 m_log << TestLog::EndSection;
245
246 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
247 glDetachShader(shader, shader);
248 expectError(GL_INVALID_OPERATION);
249 m_log << TestLog::EndSection;
250
251 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
252 glDetachShader(program, program);
253 expectError(GL_INVALID_OPERATION);
254 glDetachShader(shader, program);
255 expectError(GL_INVALID_OPERATION);
256 m_log << TestLog::EndSection;
257
258 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not attached to program.");
259 glDetachShader(program, shader);
260 expectError(GL_INVALID_OPERATION);
261 m_log << TestLog::EndSection;
262
263 glDeleteProgram(program);
264 glDeleteShader(shader);
265 });
266 ES3F_ADD_API_CASE(link_program, "Invalid glLinkProgram() usage",
267 {
268 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
269
270 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
271 glLinkProgram(-1);
272 expectError(GL_INVALID_VALUE);
273 m_log << TestLog::EndSection;
274
275 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
276 glLinkProgram(shader);
277 expectError(GL_INVALID_OPERATION);
278 m_log << TestLog::EndSection;
279
280 glDeleteShader(shader);
281
282 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is the currently active program object and transform feedback mode is active.");
283 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
284 deUint32 buf;
285 deUint32 tfID;
286 const char* tfVarying = "gl_Position";
287
288 glGenTransformFeedbacks (1, &tfID);
289 glGenBuffers (1, &buf);
290
291 glUseProgram (program.getProgram());
292 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
293 glLinkProgram (program.getProgram());
294 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
295 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
296 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
297 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
298 glBeginTransformFeedback (GL_TRIANGLES);
299 expectError (GL_NO_ERROR);
300
301 glLinkProgram (program.getProgram());
302 expectError (GL_INVALID_OPERATION);
303
304 glEndTransformFeedback ();
305 glDeleteTransformFeedbacks (1, &tfID);
306 glDeleteBuffers (1, &buf);
307 expectError (GL_NO_ERROR);
308 m_log << TestLog::EndSection;
309 });
310 ES3F_ADD_API_CASE(use_program, "Invalid glUseProgram() usage",
311 {
312 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
313
314 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
315 glUseProgram(-1);
316 expectError(GL_INVALID_VALUE);
317 m_log << TestLog::EndSection;
318
319 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
320 glUseProgram(shader);
321 expectError(GL_INVALID_OPERATION);
322 m_log << TestLog::EndSection;
323
324 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback mode is active and not paused.");
325 glu::ShaderProgram program1(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
326 glu::ShaderProgram program2(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
327 deUint32 buf;
328 deUint32 tfID;
329 const char* tfVarying = "gl_Position";
330
331 glGenTransformFeedbacks (1, &tfID);
332 glGenBuffers (1, &buf);
333
334 glUseProgram (program1.getProgram());
335 glTransformFeedbackVaryings (program1.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
336 glLinkProgram (program1.getProgram());
337 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
338 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
339 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
340 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
341 glBeginTransformFeedback (GL_TRIANGLES);
342 expectError (GL_NO_ERROR);
343
344 glUseProgram (program2.getProgram());
345 expectError (GL_INVALID_OPERATION);
346
347 glPauseTransformFeedback ();
348 glUseProgram (program2.getProgram());
349 expectError (GL_NO_ERROR);
350
351 glEndTransformFeedback ();
352 glDeleteTransformFeedbacks (1, &tfID);
353 glDeleteBuffers (1, &buf);
354 expectError (GL_NO_ERROR);
355 m_log << TestLog::EndSection;
356
357 glUseProgram(0);
358 glDeleteShader(shader);
359 });
360 ES3F_ADD_API_CASE(delete_program, "Invalid glDeleteProgram() usage",
361 {
362 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
363 glDeleteProgram(-1);
364 expectError(GL_INVALID_VALUE);
365 m_log << TestLog::EndSection;
366 });
367 ES3F_ADD_API_CASE(validate_program, "Invalid glValidateProgram() usage",
368 {
369 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
370
371 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
372 glValidateProgram(-1);
373 expectError(GL_INVALID_VALUE);
374 m_log << TestLog::EndSection;
375
376 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
377 glValidateProgram(shader);
378 expectError(GL_INVALID_OPERATION);
379 m_log << TestLog::EndSection;
380
381 glDeleteShader(shader);
382 });
383 if (glu::isContextTypeES(m_context.getRenderContext().getType()))
384 {
385 ES3F_ADD_API_CASE(get_program_binary, "Invalid glGetProgramBinary() usage",
386 {
387 glu::ShaderProgram program (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
388 glu::ShaderProgram programInvalid (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
389 GLenum binaryFormat = -1;
390 GLsizei binaryLength = -1;
391 GLint binaryPtr = -1;
392 GLint bufSize = -1;
393 GLint linkStatus = -1;
394
395 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if bufSize is less than the size of GL_PROGRAM_BINARY_LENGTH for program.");
396 glGetProgramiv (program.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
397 expectError (GL_NO_ERROR);
398 glGetProgramiv (program.getProgram(), GL_LINK_STATUS, &linkStatus);
399 m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
400 m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
401 expectError (GL_NO_ERROR);
402
403 glGetProgramBinary (program.getProgram(), 0, &binaryLength, &binaryFormat, &binaryPtr);
404 expectError (GL_INVALID_OPERATION);
405 if (bufSize > 0)
406 {
407 glGetProgramBinary (program.getProgram(), bufSize-1, &binaryLength, &binaryFormat, &binaryPtr);
408 expectError (GL_INVALID_OPERATION);
409 }
410 m_log << TestLog::EndSection;
411
412 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_LINK_STATUS for the program object is false.");
413 glGetProgramiv (programInvalid.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
414 expectError (GL_NO_ERROR);
415 glGetProgramiv (programInvalid.getProgram(), GL_LINK_STATUS, &linkStatus);
416 m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
417 m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
418 expectError (GL_NO_ERROR);
419
420 glGetProgramBinary (programInvalid.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryPtr);
421 expectError (GL_INVALID_OPERATION);
422 m_log << TestLog::EndSection;
423 });
424 }
425 ES3F_ADD_API_CASE(program_binary, "Invalid glProgramBinary() usage",
426 {
427 glu::ShaderProgram srcProgram (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
428 GLuint dstProgram = glCreateProgram();
429 GLuint unusedShader = glCreateShader(GL_VERTEX_SHADER);
430 GLenum binaryFormat = -1;
431 GLsizei binaryLength = -1;
432 std::vector<deUint8> binaryBuf;
433 GLint bufSize = -1;
434 GLint linkStatus = -1;
435
436 glGetProgramiv (srcProgram.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
437 glGetProgramiv (srcProgram.getProgram(), GL_LINK_STATUS, &linkStatus);
438 m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
439 m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
440
441 TCU_CHECK(bufSize >= 0);
442
443 if (bufSize > 0)
444 {
445 binaryBuf.resize(bufSize);
446 glGetProgramBinary (srcProgram.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryBuf[0]);
447 expectError (GL_NO_ERROR);
448
449 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not the name of an existing program object.");
450 glProgramBinary (unusedShader, binaryFormat, &binaryBuf[0], binaryLength);
451 expectError (GL_INVALID_OPERATION);
452 m_log << TestLog::EndSection;
453
454 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryFormat is not a value recognized by the implementation.");
455 glProgramBinary (dstProgram, -1, &binaryBuf[0], binaryLength);
456 expectError (GL_INVALID_ENUM);
457 m_log << TestLog::EndSection;
458 }
459
460 glDeleteShader(unusedShader);
461 glDeleteProgram(dstProgram);
462 });
463 ES3F_ADD_API_CASE(program_parameteri, "Invalid glProgramParameteri() usage",
464 {
465 GLuint program = glCreateProgram();
466
467 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of an existing program object.");
468 glProgramParameteri (0, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
469 expectError (GL_INVALID_VALUE);
470 m_log << TestLog::EndSection;
471
472 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT.");
473 glProgramParameteri (program, -1, GL_TRUE);
474 expectError (GL_INVALID_ENUM);
475 m_log << TestLog::EndSection;
476
477 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE.");
478 glProgramParameteri (program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
479 expectError (GL_INVALID_VALUE);
480 m_log << TestLog::EndSection;
481
482 glDeleteProgram(program);
483 });
484 ES3F_ADD_API_CASE(gen_samplers, "Invalid glGenSamplers() usage",
485 {
486 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
487 GLuint sampler;
488 glGenSamplers (-1, &sampler);
489 expectError (GL_INVALID_VALUE);
490 m_log << TestLog::EndSection;
491 });
492 ES3F_ADD_API_CASE(bind_sampler, "Invalid glBindSampler() usage",
493 {
494 int maxTexImageUnits;
495 GLuint sampler;
496 glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits);
497 glGenSamplers (1, &sampler);
498
499 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if unit is greater than or equal to the value of GL_MAX_COMBIED_TEXTURE_IMAGE_UNITS.");
500 glBindSampler (maxTexImageUnits, sampler);
501 expectError (GL_INVALID_VALUE);
502 m_log << TestLog::EndSection;
503
504 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not zero or a name previously returned from a call to glGenSamplers.");
505 glBindSampler (1, -1);
506 expectError (GL_INVALID_OPERATION);
507 m_log << TestLog::EndSection;
508
509 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler has been deleted by a call to glDeleteSamplers.");
510 glDeleteSamplers(1, &sampler);
511 glBindSampler (1, sampler);
512 expectError (GL_INVALID_OPERATION);
513 m_log << TestLog::EndSection;
514 });
515 ES3F_ADD_API_CASE(delete_samplers, "Invalid glDeleteSamplers() usage",
516 {
517 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
518 glDeleteSamplers(-1, 0);
519 expectError (GL_INVALID_VALUE);
520 m_log << TestLog::EndSection;
521 });
522 ES3F_ADD_API_CASE(get_sampler_parameteriv, "Invalid glGetSamplerParameteriv() usage",
523 {
524 int params = -1;
525 GLuint sampler;
526 glGenSamplers (1, &sampler);
527
528 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to glGenSamplers.");
529 glGetSamplerParameteriv (-1, GL_TEXTURE_MAG_FILTER, ¶ms);
530 expectError (GL_INVALID_OPERATION);
531 m_log << TestLog::EndSection;
532
533 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
534 glGetSamplerParameteriv (sampler, -1, ¶ms);
535 expectError (GL_INVALID_ENUM);
536 m_log << TestLog::EndSection;
537
538 glDeleteSamplers(1, &sampler);
539 });
540 ES3F_ADD_API_CASE(get_sampler_parameterfv, "Invalid glGetSamplerParameterfv() usage",
541 {
542 float params = 0.0f;
543 GLuint sampler;
544 glGenSamplers (1, &sampler);
545
546 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to glGenSamplers.");
547 glGetSamplerParameterfv (-1, GL_TEXTURE_MAG_FILTER, ¶ms);
548 expectError (GL_INVALID_OPERATION);
549 m_log << TestLog::EndSection;
550
551 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
552 glGetSamplerParameterfv (sampler, -1, ¶ms);
553 expectError (GL_INVALID_ENUM);
554 m_log << TestLog::EndSection;
555
556 glDeleteSamplers(1, &sampler);
557 });
558 ES3F_ADD_API_CASE(sampler_parameteri, "Invalid glSamplerParameteri() usage",
559 {
560 GLuint sampler;
561 glGenSamplers (1, &sampler);
562
563 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
564 glSamplerParameteri (-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
565 expectError (GL_INVALID_OPERATION);
566 m_log << TestLog::EndSection;
567
568 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
569 glSamplerParameteri (sampler, GL_TEXTURE_WRAP_S, -1);
570 expectError (GL_INVALID_ENUM);
571 m_log << TestLog::EndSection;
572
573 glDeleteSamplers(1, &sampler);
574 });
575 ES3F_ADD_API_CASE(sampler_parameteriv, "Invalid glSamplerParameteriv() usage",
576 {
577 int params = -1;
578 GLuint sampler;
579 glGenSamplers (1, &sampler);
580
581 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
582 params = GL_CLAMP_TO_EDGE;
583 glSamplerParameteriv (-1, GL_TEXTURE_WRAP_S, ¶ms);
584 expectError (GL_INVALID_OPERATION);
585 m_log << TestLog::EndSection;
586
587 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
588 params = -1;
589 glSamplerParameteriv (sampler, GL_TEXTURE_WRAP_S, ¶ms);
590 expectError (GL_INVALID_ENUM);
591 m_log << TestLog::EndSection;
592
593 glDeleteSamplers(1, &sampler);
594 });
595 ES3F_ADD_API_CASE(sampler_parameterf, "Invalid glSamplerParameterf() usage",
596 {
597 GLuint sampler;
598 glGenSamplers (1, &sampler);
599
600 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
601 glSamplerParameterf (-1, GL_TEXTURE_MIN_LOD, -1000.0f);
602 expectError (GL_INVALID_OPERATION);
603 m_log << TestLog::EndSection;
604
605 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
606 glSamplerParameterf (sampler, GL_TEXTURE_WRAP_S, -1.0f);
607 expectError (GL_INVALID_ENUM);
608 m_log << TestLog::EndSection;
609
610 glDeleteSamplers(1, &sampler);
611 });
612 ES3F_ADD_API_CASE(sampler_parameterfv, "Invalid glSamplerParameterfv() usage",
613 {
614 float params = 0.0f;
615 GLuint sampler;
616 glGenSamplers (1, &sampler);
617
618 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to glGenSamplers.");
619 params = -1000.0f;
620 glSamplerParameterfv (-1, GL_TEXTURE_WRAP_S, ¶ms);
621 expectError (GL_INVALID_OPERATION);
622 m_log << TestLog::EndSection;
623
624 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
625 params = -1.0f;
626 glSamplerParameterfv (sampler, GL_TEXTURE_WRAP_S, ¶ms);
627 expectError (GL_INVALID_ENUM);
628 m_log << TestLog::EndSection;
629
630 glDeleteSamplers(1, &sampler);
631 });
632
633 // Shader data commands
634
635 ES3F_ADD_API_CASE(get_attrib_location, "Invalid glGetAttribLocation() usage",
636 {
637 GLuint programEmpty = glCreateProgram();
638 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
639
640 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
641
642 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
643 glBindAttribLocation (programEmpty, 0, "test");
644 glGetAttribLocation (programEmpty, "test");
645 expectError (GL_INVALID_OPERATION);
646 m_log << TestLog::EndSection;
647
648 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a program or shader object.");
649 glUseProgram (program.getProgram());
650 glBindAttribLocation (program.getProgram(), 0, "test");
651 expectError (GL_NO_ERROR);
652 glGetAttribLocation (program.getProgram(), "test");
653 expectError (GL_NO_ERROR);
654 glGetAttribLocation (-2, "test");
655 expectError (GL_INVALID_VALUE);
656 m_log << TestLog::EndSection;
657
658 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
659 glGetAttribLocation (shader, "test");
660 expectError (GL_INVALID_OPERATION);
661 m_log << TestLog::EndSection;
662
663 glUseProgram (0);
664 glDeleteShader (shader);
665 glDeleteProgram (programEmpty);
666 });
667 ES3F_ADD_API_CASE(get_uniform_location, "Invalid glGetUniformLocation() usage",
668 {
669 GLuint programEmpty = glCreateProgram();
670 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
671
672 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
673
674 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
675 glGetUniformLocation(programEmpty, "test");
676 expectError(GL_INVALID_OPERATION);
677 m_log << TestLog::EndSection;
678
679 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
680 glUseProgram(program.getProgram());
681 glGetUniformLocation(-2, "test");
682 expectError(GL_INVALID_VALUE);
683 m_log << TestLog::EndSection;
684
685 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
686 glGetAttribLocation(shader, "test");
687 expectError(GL_INVALID_OPERATION);
688 m_log << TestLog::EndSection;
689
690 glUseProgram(0);
691 glDeleteProgram(programEmpty);
692 glDeleteShader(shader);
693 });
694 ES3F_ADD_API_CASE(bind_attrib_location, "Invalid glBindAttribLocation() usage",
695 {
696 GLuint program = glCreateProgram();
697 GLuint maxIndex = m_context.getContextInfo().getInt(GL_MAX_VERTEX_ATTRIBS);
698 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
699
700 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
701 glBindAttribLocation(program, maxIndex, "test");
702 expectError(GL_INVALID_VALUE);
703 m_log << TestLog::EndSection;
704
705 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
706 glBindAttribLocation(program, maxIndex-1, "gl_test");
707 expectError(GL_INVALID_OPERATION);
708 m_log << TestLog::EndSection;
709
710 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
711 glBindAttribLocation(-1, maxIndex-1, "test");
712 expectError(GL_INVALID_VALUE);
713 m_log << TestLog::EndSection;
714
715 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
716 glBindAttribLocation(shader, maxIndex-1, "test");
717 expectError(GL_INVALID_OPERATION);
718 m_log << TestLog::EndSection;
719
720 glDeleteProgram(program);
721 glDeleteShader(shader);
722 });
723 ES3F_ADD_API_CASE(uniform_block_binding, "Invalid glUniformBlockBinding() usage",
724 {
725 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
726
727 glUseProgram (program.getProgram());
728
729 GLint maxUniformBufferBindings;
730 GLint numActiveUniforms = -1;
731 GLint numActiveBlocks = -1;
732 glGetIntegerv (GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
733 glGetProgramiv (program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
734 glGetProgramiv (program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
735 m_log << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings << TestLog::EndMessage;
736 m_log << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << TestLog::EndMessage;
737 m_log << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << TestLog::EndMessage;
738 expectError (GL_NO_ERROR);
739
740 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program.");
741 glUniformBlockBinding(program.getProgram(), -1, 0);
742 expectError(GL_INVALID_VALUE);
743 glUniformBlockBinding(program.getProgram(), 5, 0);
744 expectError(GL_INVALID_VALUE);
745 m_log << tcu::TestLog::EndSection;
746
747 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if uniformBlockBinding is greater than or equal to the value of GL_MAX_UNIFORM_BUFFER_BINDINGS.");
748 glUniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0);
749 expectError(GL_INVALID_VALUE);
750 m_log << tcu::TestLog::EndSection;
751
752 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object generated by the GL.");
753 glUniformBlockBinding(-1, 0, 0);
754 expectError(GL_INVALID_VALUE);
755 m_log << tcu::TestLog::EndSection;
756 });
757
758 // glUniform*f
759
760 ES3F_ADD_API_CASE(uniformf_invalid_program, "Invalid glUniform{1234}f() usage",
761 {
762 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
763 glUseProgram(0);
764 glUniform1f(-1, 0.0f);
765 expectError(GL_INVALID_OPERATION);
766 glUniform2f(-1, 0.0f, 0.0f);
767 expectError(GL_INVALID_OPERATION);
768 glUniform3f(-1, 0.0f, 0.0f, 0.0f);
769 expectError(GL_INVALID_OPERATION);
770 glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
771 expectError(GL_INVALID_OPERATION);
772 m_log << tcu::TestLog::EndSection;
773 });
774 ES3F_ADD_API_CASE(uniformf_incompatible_type, "Invalid glUniform{1234}f() usage",
775 {
776 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
777
778 glUseProgram(program.getProgram());
779 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
780 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
781 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
782 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
783 expectError(GL_NO_ERROR);
784
785 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
786 {
787 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
788 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
789 }
790
791 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
792 glUseProgram(program.getProgram());
793 glUniform1f(vec4_v, 0.0f);
794 expectError(GL_INVALID_OPERATION);
795 glUniform2f(vec4_v, 0.0f, 0.0f);
796 expectError(GL_INVALID_OPERATION);
797 glUniform3f(vec4_v, 0.0f, 0.0f, 0.0f);
798 expectError(GL_INVALID_OPERATION);
799 glUniform4f(vec4_v, 0.0f, 0.0f, 0.0f, 0.0f);
800 expectError(GL_NO_ERROR);
801 m_log << tcu::TestLog::EndSection;
802
803 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}f is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
804 glUseProgram(program.getProgram());
805 glUniform4f(ivec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
806 expectError(GL_INVALID_OPERATION);
807 glUniform4f(uvec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
808 expectError(GL_INVALID_OPERATION);
809 m_log << tcu::TestLog::EndSection;
810
811 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
812 glUseProgram(program.getProgram());
813 glUniform1f(sampler_f, 0.0f);
814 expectError(GL_INVALID_OPERATION);
815 m_log << tcu::TestLog::EndSection;
816
817 glUseProgram(0);
818 });
819 ES3F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage",
820 {
821 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
822
823 glUseProgram(program.getProgram());
824 expectError(GL_NO_ERROR);
825
826 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
827 glUseProgram(program.getProgram());
828 glUniform1f(-2, 0.0f);
829 expectError(GL_INVALID_OPERATION);
830 glUniform2f(-2, 0.0f, 0.0f);
831 expectError(GL_INVALID_OPERATION);
832 glUniform3f(-2, 0.0f, 0.0f, 0.0f);
833 expectError(GL_INVALID_OPERATION);
834 glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
835 expectError(GL_INVALID_OPERATION);
836
837 glUseProgram(program.getProgram());
838 glUniform1f(-1, 0.0f);
839 expectError(GL_NO_ERROR);
840 glUniform2f(-1, 0.0f, 0.0f);
841 expectError(GL_NO_ERROR);
842 glUniform3f(-1, 0.0f, 0.0f, 0.0f);
843 expectError(GL_NO_ERROR);
844 glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
845 expectError(GL_NO_ERROR);
846 m_log << tcu::TestLog::EndSection;
847
848 glUseProgram(0);
849 });
850
851 // glUniform*fv
852
853 ES3F_ADD_API_CASE(uniformfv_invalid_program, "Invalid glUniform{1234}fv() usage",
854 {
855 std::vector<GLfloat> data(4);
856
857 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
858 glUseProgram(0);
859 glUniform1fv(-1, 1, &data[0]);
860 expectError(GL_INVALID_OPERATION);
861 glUniform2fv(-1, 1, &data[0]);
862 expectError(GL_INVALID_OPERATION);
863 glUniform3fv(-1, 1, &data[0]);
864 expectError(GL_INVALID_OPERATION);
865 glUniform4fv(-1, 1, &data[0]);
866 expectError(GL_INVALID_OPERATION);
867 m_log << tcu::TestLog::EndSection;
868 });
869 ES3F_ADD_API_CASE(uniformfv_incompatible_type, "Invalid glUniform{1234}fv() usage",
870 {
871 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
872
873 glUseProgram(program.getProgram());
874 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
875 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
876 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
877 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
878 expectError(GL_NO_ERROR);
879
880 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
881 {
882 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
883 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
884 }
885
886 std::vector<GLfloat> data(4);
887
888 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
889 glUseProgram(program.getProgram());
890 glUniform1fv(vec4_v, 1, &data[0]);
891 expectError(GL_INVALID_OPERATION);
892 glUniform2fv(vec4_v, 1, &data[0]);
893 expectError(GL_INVALID_OPERATION);
894 glUniform3fv(vec4_v, 1, &data[0]);
895 expectError(GL_INVALID_OPERATION);
896 glUniform4fv(vec4_v, 1, &data[0]);
897 expectError(GL_NO_ERROR);
898 m_log << tcu::TestLog::EndSection;
899
900 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}fv is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
901 glUseProgram(program.getProgram());
902 glUniform4fv(ivec4_f, 1, &data[0]);
903 expectError(GL_INVALID_OPERATION);
904 glUniform4fv(uvec4_f, 1, &data[0]);
905 expectError(GL_INVALID_OPERATION);
906 m_log << tcu::TestLog::EndSection;
907
908 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
909 glUseProgram(program.getProgram());
910 glUniform1fv(sampler_f, 1, &data[0]);
911 expectError(GL_INVALID_OPERATION);
912 m_log << tcu::TestLog::EndSection;
913
914 glUseProgram(0);
915 });
916 ES3F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage",
917 {
918 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
919
920 glUseProgram(program.getProgram());
921 expectError(GL_NO_ERROR);
922
923 std::vector<GLfloat> data(4);
924
925 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
926 glUseProgram(program.getProgram());
927 glUniform1fv(-2, 1, &data[0]);
928 expectError(GL_INVALID_OPERATION);
929 glUniform2fv(-2, 1, &data[0]);
930 expectError(GL_INVALID_OPERATION);
931 glUniform3fv(-2, 1, &data[0]);
932 expectError(GL_INVALID_OPERATION);
933 glUniform4fv(-2, 1, &data[0]);
934 expectError(GL_INVALID_OPERATION);
935
936 glUseProgram(program.getProgram());
937 glUniform1fv(-1, 1, &data[0]);
938 expectError(GL_NO_ERROR);
939 glUniform2fv(-1, 1, &data[0]);
940 expectError(GL_NO_ERROR);
941 glUniform3fv(-1, 1, &data[0]);
942 expectError(GL_NO_ERROR);
943 glUniform4fv(-1, 1, &data[0]);
944 expectError(GL_NO_ERROR);
945 m_log << tcu::TestLog::EndSection;
946
947 glUseProgram(0);
948 });
949 ES3F_ADD_API_CASE(uniformfv_invalid_count, "Invalid glUniform{1234}fv() usage",
950 {
951 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
952
953 glUseProgram (program.getProgram());
954 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
955 expectError(GL_NO_ERROR);
956
957 if (vec4_v == -1)
958 {
959 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
960 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
961 }
962
963 std::vector<GLfloat> data(8);
964
965 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
966 glUseProgram(program.getProgram());
967 glUniform1fv(vec4_v, 2, &data[0]);
968 expectError(GL_INVALID_OPERATION);
969 glUniform2fv(vec4_v, 2, &data[0]);
970 expectError(GL_INVALID_OPERATION);
971 glUniform3fv(vec4_v, 2, &data[0]);
972 expectError(GL_INVALID_OPERATION);
973 glUniform4fv(vec4_v, 2, &data[0]);
974 expectError(GL_INVALID_OPERATION);
975 m_log << tcu::TestLog::EndSection;
976
977 glUseProgram(0);
978 });
979
980 // glUniform*i
981
982 ES3F_ADD_API_CASE(uniformi_invalid_program, "Invalid glUniform{1234}i() usage",
983 {
984 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
985 glUseProgram(0);
986 glUniform1i(-1, 0);
987 expectError(GL_INVALID_OPERATION);
988 glUniform2i(-1, 0, 0);
989 expectError(GL_INVALID_OPERATION);
990 glUniform3i(-1, 0, 0, 0);
991 expectError(GL_INVALID_OPERATION);
992 glUniform4i(-1, 0, 0, 0, 0);
993 expectError(GL_INVALID_OPERATION);
994 m_log << tcu::TestLog::EndSection;
995 });
996 ES3F_ADD_API_CASE(uniformi_incompatible_type, "Invalid glUniform{1234}i() usage",
997 {
998 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
999
1000 glUseProgram(program.getProgram());
1001 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1002 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1003 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1004 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1005 expectError(GL_NO_ERROR);
1006
1007 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1008 {
1009 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1010 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1011 }
1012
1013 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1014 glUseProgram(program.getProgram());
1015 glUniform1i(ivec4_f, 0);
1016 expectError(GL_INVALID_OPERATION);
1017 glUniform2i(ivec4_f, 0, 0);
1018 expectError(GL_INVALID_OPERATION);
1019 glUniform3i(ivec4_f, 0, 0, 0);
1020 expectError(GL_INVALID_OPERATION);
1021 glUniform4i(ivec4_f, 0, 0, 0, 0);
1022 expectError(GL_NO_ERROR);
1023 m_log << tcu::TestLog::EndSection;
1024
1025 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type unsigned int, uvec2, uvec3, uvec4, or an array of these.");
1026 glUseProgram(program.getProgram());
1027 glUniform1i(uvec4_f, 0);
1028 expectError(GL_INVALID_OPERATION);
1029 glUniform2i(uvec4_f, 0, 0);
1030 expectError(GL_INVALID_OPERATION);
1031 glUniform3i(uvec4_f, 0, 0, 0);
1032 expectError(GL_INVALID_OPERATION);
1033 glUniform4i(uvec4_f, 0, 0, 0, 0);
1034 expectError(GL_INVALID_OPERATION);
1035 m_log << tcu::TestLog::EndSection;
1036
1037 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1038 glUseProgram(program.getProgram());
1039 glUniform1i(vec4_v, 0);
1040 expectError(GL_INVALID_OPERATION);
1041 glUniform2i(vec4_v, 0, 0);
1042 expectError(GL_INVALID_OPERATION);
1043 glUniform3i(vec4_v, 0, 0, 0);
1044 expectError(GL_INVALID_OPERATION);
1045 glUniform4i(vec4_v, 0, 0, 0, 0);
1046 expectError(GL_INVALID_OPERATION);
1047 m_log << tcu::TestLog::EndSection;
1048
1049 glUseProgram(0);
1050 });
1051 ES3F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage",
1052 {
1053 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1054
1055 glUseProgram(program.getProgram());
1056 expectError(GL_NO_ERROR);
1057
1058 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1059 glUseProgram(program.getProgram());
1060 glUniform1i(-2, 0);
1061 expectError(GL_INVALID_OPERATION);
1062 glUniform2i(-2, 0, 0);
1063 expectError(GL_INVALID_OPERATION);
1064 glUniform3i(-2, 0, 0, 0);
1065 expectError(GL_INVALID_OPERATION);
1066 glUniform4i(-2, 0, 0, 0, 0);
1067 expectError(GL_INVALID_OPERATION);
1068
1069 glUseProgram(program.getProgram());
1070 glUniform1i(-1, 0);
1071 expectError(GL_NO_ERROR);
1072 glUniform2i(-1, 0, 0);
1073 expectError(GL_NO_ERROR);
1074 glUniform3i(-1, 0, 0, 0);
1075 expectError(GL_NO_ERROR);
1076 glUniform4i(-1, 0, 0, 0, 0);
1077 expectError(GL_NO_ERROR);
1078 m_log << tcu::TestLog::EndSection;
1079
1080 glUseProgram(0);
1081 });
1082
1083 // glUniform*iv
1084
1085 ES3F_ADD_API_CASE(uniformiv_invalid_program, "Invalid glUniform{1234}iv() usage",
1086 {
1087 std::vector<GLint> data(4);
1088
1089 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1090 glUseProgram(0);
1091 glUniform1iv(-1, 1, &data[0]);
1092 expectError(GL_INVALID_OPERATION);
1093 glUniform2iv(-1, 1, &data[0]);
1094 expectError(GL_INVALID_OPERATION);
1095 glUniform3iv(-1, 1, &data[0]);
1096 expectError(GL_INVALID_OPERATION);
1097 glUniform4iv(-1, 1, &data[0]);
1098 expectError(GL_INVALID_OPERATION);
1099 m_log << tcu::TestLog::EndSection;
1100 });
1101 ES3F_ADD_API_CASE(uniformiv_incompatible_type, "Invalid glUniform{1234}iv() usage",
1102 {
1103 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1104
1105 glUseProgram(program.getProgram());
1106 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1107 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1108 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1109 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1110 expectError(GL_NO_ERROR);
1111
1112 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1113 {
1114 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1115 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1116 }
1117
1118 std::vector<GLint> data(4);
1119
1120 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1121 glUseProgram(program.getProgram());
1122 glUniform1iv(ivec4_f, 1, &data[0]);
1123 expectError(GL_INVALID_OPERATION);
1124 glUniform2iv(ivec4_f, 1, &data[0]);
1125 expectError(GL_INVALID_OPERATION);
1126 glUniform3iv(ivec4_f, 1, &data[0]);
1127 expectError(GL_INVALID_OPERATION);
1128 glUniform4iv(ivec4_f, 1, &data[0]);
1129 expectError(GL_NO_ERROR);
1130 m_log << tcu::TestLog::EndSection;
1131
1132 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1133 glUseProgram(program.getProgram());
1134 glUniform1iv(vec4_v, 1, &data[0]);
1135 expectError(GL_INVALID_OPERATION);
1136 glUniform2iv(vec4_v, 1, &data[0]);
1137 expectError(GL_INVALID_OPERATION);
1138 glUniform3iv(vec4_v, 1, &data[0]);
1139 expectError(GL_INVALID_OPERATION);
1140 glUniform4iv(vec4_v, 1, &data[0]);
1141 expectError(GL_INVALID_OPERATION);
1142 m_log << tcu::TestLog::EndSection;
1143
1144 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a uniform variable of type unsigned int, uvec2, uvec3 or uvec4.");
1145 glUseProgram(program.getProgram());
1146 glUniform1iv(uvec4_f, 1, &data[0]);
1147 expectError(GL_INVALID_OPERATION);
1148 glUniform2iv(uvec4_f, 1, &data[0]);
1149 expectError(GL_INVALID_OPERATION);
1150 glUniform3iv(uvec4_f, 1, &data[0]);
1151 expectError(GL_INVALID_OPERATION);
1152 glUniform4iv(uvec4_f, 1, &data[0]);
1153 expectError(GL_INVALID_OPERATION);
1154 m_log << tcu::TestLog::EndSection;
1155
1156 glUseProgram(0);
1157 });
1158 ES3F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage",
1159 {
1160 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1161
1162 glUseProgram(program.getProgram());
1163 expectError(GL_NO_ERROR);
1164
1165 std::vector<GLint> data(4);
1166
1167 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1168 glUseProgram(program.getProgram());
1169 glUniform1iv(-2, 1, &data[0]);
1170 expectError(GL_INVALID_OPERATION);
1171 glUniform2iv(-2, 1, &data[0]);
1172 expectError(GL_INVALID_OPERATION);
1173 glUniform3iv(-2, 1, &data[0]);
1174 expectError(GL_INVALID_OPERATION);
1175 glUniform4iv(-2, 1, &data[0]);
1176 expectError(GL_INVALID_OPERATION);
1177
1178 glUseProgram(program.getProgram());
1179 glUniform1iv(-1, 1, &data[0]);
1180 expectError(GL_NO_ERROR);
1181 glUniform2iv(-1, 1, &data[0]);
1182 expectError(GL_NO_ERROR);
1183 glUniform3iv(-1, 1, &data[0]);
1184 expectError(GL_NO_ERROR);
1185 glUniform4iv(-1, 1, &data[0]);
1186 expectError(GL_NO_ERROR);
1187 m_log << tcu::TestLog::EndSection;
1188
1189 glUseProgram(0);
1190 });
1191 ES3F_ADD_API_CASE(uniformiv_invalid_count, "Invalid glUniform{1234}iv() usage",
1192 {
1193 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1194
1195 glUseProgram (program.getProgram());
1196 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1197 expectError(GL_NO_ERROR);
1198
1199 if (ivec4_f == -1)
1200 {
1201 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1202 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1203 }
1204
1205 std::vector<GLint> data(8);
1206
1207 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1208 glUseProgram(program.getProgram());
1209 glUniform1iv(ivec4_f, 2, &data[0]);
1210 expectError(GL_INVALID_OPERATION);
1211 glUniform2iv(ivec4_f, 2, &data[0]);
1212 expectError(GL_INVALID_OPERATION);
1213 glUniform3iv(ivec4_f, 2, &data[0]);
1214 expectError(GL_INVALID_OPERATION);
1215 glUniform4iv(ivec4_f, 2, &data[0]);
1216 expectError(GL_INVALID_OPERATION);
1217 m_log << tcu::TestLog::EndSection;
1218
1219 glUseProgram(0);
1220 });
1221
1222 // glUniform{1234}ui
1223
1224 ES3F_ADD_API_CASE(uniformui_invalid_program, "Invalid glUniform{234}ui() usage",
1225 {
1226 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1227 glUseProgram(0);
1228 glUniform1ui(-1, 0);
1229 expectError(GL_INVALID_OPERATION);
1230 glUniform2ui(-1, 0, 0);
1231 expectError(GL_INVALID_OPERATION);
1232 glUniform3ui(-1, 0, 0, 0);
1233 expectError(GL_INVALID_OPERATION);
1234 glUniform4ui(-1, 0, 0, 0, 0);
1235 expectError(GL_INVALID_OPERATION);
1236 m_log << tcu::TestLog::EndSection;
1237 });
1238 ES3F_ADD_API_CASE(uniformui_incompatible_type, "Invalid glUniform{1234}ui() usage",
1239 {
1240 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1241
1242 glUseProgram(program.getProgram());
1243 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1244 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1245 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1246 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1247 expectError(GL_NO_ERROR);
1248
1249 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1250 {
1251 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1252 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1253 }
1254
1255 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1256 glUseProgram(program.getProgram());
1257 glUniform1ui(uvec4_f, 0);
1258 expectError(GL_INVALID_OPERATION);
1259 glUniform2ui(uvec4_f, 0, 0);
1260 expectError(GL_INVALID_OPERATION);
1261 glUniform3ui(uvec4_f, 0, 0, 0);
1262 expectError(GL_INVALID_OPERATION);
1263 glUniform4ui(uvec4_f, 0, 0, 0, 0);
1264 expectError(GL_NO_ERROR);
1265 m_log << tcu::TestLog::EndSection;
1266
1267 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type int, ivec2, ivec3, ivec4, or an array of these.");
1268 glUseProgram(program.getProgram());
1269 glUniform1ui(ivec4_f, 0);
1270 expectError(GL_INVALID_OPERATION);
1271 glUniform2ui(ivec4_f, 0, 0);
1272 expectError(GL_INVALID_OPERATION);
1273 glUniform3ui(ivec4_f, 0, 0, 0);
1274 expectError(GL_INVALID_OPERATION);
1275 glUniform4ui(ivec4_f, 0, 0, 0, 0);
1276 expectError(GL_INVALID_OPERATION);
1277 m_log << tcu::TestLog::EndSection;
1278
1279 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1280 glUseProgram(program.getProgram());
1281 glUniform1ui(vec4_v, 0);
1282 expectError(GL_INVALID_OPERATION);
1283 glUniform2ui(vec4_v, 0, 0);
1284 expectError(GL_INVALID_OPERATION);
1285 glUniform3ui(vec4_v, 0, 0, 0);
1286 expectError(GL_INVALID_OPERATION);
1287 glUniform4ui(vec4_v, 0, 0, 0, 0);
1288 expectError(GL_INVALID_OPERATION);
1289 m_log << tcu::TestLog::EndSection;
1290
1291 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1292 glUseProgram(program.getProgram());
1293 glUniform1ui(sampler_f, 0);
1294 expectError(GL_INVALID_OPERATION);
1295 m_log << tcu::TestLog::EndSection;
1296
1297 glUseProgram(0);
1298 });
1299 ES3F_ADD_API_CASE(uniformui_invalid_location, "Invalid glUniform{1234}ui() usage",
1300 {
1301 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1302
1303 glUseProgram(program.getProgram());
1304 expectError(GL_NO_ERROR);
1305
1306 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1307 glUseProgram(program.getProgram());
1308 glUniform1i(-2, 0);
1309 expectError(GL_INVALID_OPERATION);
1310 glUniform2i(-2, 0, 0);
1311 expectError(GL_INVALID_OPERATION);
1312 glUniform3i(-2, 0, 0, 0);
1313 expectError(GL_INVALID_OPERATION);
1314 glUniform4i(-2, 0, 0, 0, 0);
1315 expectError(GL_INVALID_OPERATION);
1316
1317 glUseProgram(program.getProgram());
1318 glUniform1i(-1, 0);
1319 expectError(GL_NO_ERROR);
1320 glUniform2i(-1, 0, 0);
1321 expectError(GL_NO_ERROR);
1322 glUniform3i(-1, 0, 0, 0);
1323 expectError(GL_NO_ERROR);
1324 glUniform4i(-1, 0, 0, 0, 0);
1325 expectError(GL_NO_ERROR);
1326 m_log << tcu::TestLog::EndSection;
1327
1328 glUseProgram(0);
1329 });
1330
1331 // glUniform{1234}uiv
1332
1333 ES3F_ADD_API_CASE(uniformuiv_invalid_program, "Invalid glUniform{234}uiv() usage",
1334 {
1335 std::vector<GLuint> data(4);
1336
1337 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1338 glUseProgram(0);
1339 glUniform1uiv(-1, 1, &data[0]);
1340 expectError(GL_INVALID_OPERATION);
1341 glUniform2uiv(-1, 1, &data[0]);
1342 expectError(GL_INVALID_OPERATION);
1343 glUniform3uiv(-1, 1, &data[0]);
1344 expectError(GL_INVALID_OPERATION);
1345 glUniform4uiv(-1, 1, &data[0]);
1346 expectError(GL_INVALID_OPERATION);
1347 m_log << tcu::TestLog::EndSection;
1348 });
1349 ES3F_ADD_API_CASE(uniformuiv_incompatible_type, "Invalid glUniform{1234}uiv() usage",
1350 {
1351 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1352
1353 glUseProgram(program.getProgram());
1354 GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1355 GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1356 GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1357 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1358 expectError(GL_NO_ERROR);
1359
1360 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1361 {
1362 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1363 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1364 }
1365
1366 std::vector<GLuint> data(4);
1367
1368 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1369 glUseProgram(program.getProgram());
1370 glUniform1uiv(uvec4_f, 1, &data[0]);
1371 expectError(GL_INVALID_OPERATION);
1372 glUniform2uiv(uvec4_f, 1, &data[0]);
1373 expectError(GL_INVALID_OPERATION);
1374 glUniform3uiv(uvec4_f, 1, &data[0]);
1375 expectError(GL_INVALID_OPERATION);
1376 glUniform4uiv(uvec4_f, 1, &data[0]);
1377 expectError(GL_NO_ERROR);
1378 m_log << tcu::TestLog::EndSection;
1379
1380 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1381 glUseProgram(program.getProgram());
1382 glUniform1uiv(vec4_v, 1, &data[0]);
1383 expectError(GL_INVALID_OPERATION);
1384 glUniform2uiv(vec4_v, 1, &data[0]);
1385 expectError(GL_INVALID_OPERATION);
1386 glUniform3uiv(vec4_v, 1, &data[0]);
1387 expectError(GL_INVALID_OPERATION);
1388 glUniform4uiv(vec4_v, 1, &data[0]);
1389 expectError(GL_INVALID_OPERATION);
1390 m_log << tcu::TestLog::EndSection;
1391
1392 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a uniform variable of type int, ivec2, ivec3 or ivec4.");
1393 glUseProgram(program.getProgram());
1394 glUniform1uiv(ivec4_f, 1, &data[0]);
1395 expectError(GL_INVALID_OPERATION);
1396 glUniform2uiv(ivec4_f, 1, &data[0]);
1397 expectError(GL_INVALID_OPERATION);
1398 glUniform3uiv(ivec4_f, 1, &data[0]);
1399 expectError(GL_INVALID_OPERATION);
1400 glUniform4uiv(ivec4_f, 1, &data[0]);
1401 expectError(GL_INVALID_OPERATION);
1402 m_log << tcu::TestLog::EndSection;
1403
1404 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1405 glUseProgram(program.getProgram());
1406 glUniform1uiv(sampler_f, 1, &data[0]);
1407 expectError(GL_INVALID_OPERATION);
1408 m_log << tcu::TestLog::EndSection;
1409
1410 glUseProgram(0);
1411 });
1412 ES3F_ADD_API_CASE(uniformuiv_invalid_location, "Invalid glUniform{1234}uiv() usage",
1413 {
1414 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1415
1416 glUseProgram(program.getProgram());
1417 expectError(GL_NO_ERROR);
1418
1419 std::vector<GLuint> data(4);
1420
1421 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1422 glUseProgram(program.getProgram());
1423 glUniform1uiv(-2, 1, &data[0]);
1424 expectError(GL_INVALID_OPERATION);
1425 glUniform2uiv(-2, 1, &data[0]);
1426 expectError(GL_INVALID_OPERATION);
1427 glUniform3uiv(-2, 1, &data[0]);
1428 expectError(GL_INVALID_OPERATION);
1429 glUniform4uiv(-2, 1, &data[0]);
1430 expectError(GL_INVALID_OPERATION);
1431
1432 glUseProgram(program.getProgram());
1433 glUniform1uiv(-1, 1, &data[0]);
1434 expectError(GL_NO_ERROR);
1435 glUniform2uiv(-1, 1, &data[0]);
1436 expectError(GL_NO_ERROR);
1437 glUniform3uiv(-1, 1, &data[0]);
1438 expectError(GL_NO_ERROR);
1439 glUniform4uiv(-1, 1, &data[0]);
1440 expectError(GL_NO_ERROR);
1441 m_log << tcu::TestLog::EndSection;
1442
1443 glUseProgram(0);
1444 });
1445 ES3F_ADD_API_CASE(uniformuiv_invalid_count, "Invalid glUniform{1234}uiv() usage",
1446 {
1447 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1448
1449 glUseProgram (program.getProgram());
1450 int uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1451 expectError(GL_NO_ERROR);
1452
1453 if (uvec4_f == -1)
1454 {
1455 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1456 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1457 }
1458
1459 std::vector<GLuint> data(8);
1460
1461 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1462 glUseProgram(program.getProgram());
1463 glUniform1uiv(uvec4_f, 2, &data[0]);
1464 expectError(GL_INVALID_OPERATION);
1465 glUniform2uiv(uvec4_f, 2, &data[0]);
1466 expectError(GL_INVALID_OPERATION);
1467 glUniform3uiv(uvec4_f, 2, &data[0]);
1468 expectError(GL_INVALID_OPERATION);
1469 glUniform4uiv(uvec4_f, 2, &data[0]);
1470 expectError(GL_INVALID_OPERATION);
1471 m_log << tcu::TestLog::EndSection;
1472
1473 glUseProgram(0);
1474 });
1475
1476
1477 // glUniformMatrix*fv
1478
1479 ES3F_ADD_API_CASE(uniform_matrixfv_invalid_program, "Invalid glUniformMatrix{234}fv() usage",
1480 {
1481 std::vector<GLfloat> data(16);
1482
1483 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
1484 glUseProgram(0);
1485 glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1486 expectError(GL_INVALID_OPERATION);
1487 glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1488 expectError(GL_INVALID_OPERATION);
1489 glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1490 expectError(GL_INVALID_OPERATION);
1491
1492 glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1493 expectError(GL_INVALID_OPERATION);
1494 glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1495 expectError(GL_INVALID_OPERATION);
1496 glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1497 expectError(GL_INVALID_OPERATION);
1498 glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1499 expectError(GL_INVALID_OPERATION);
1500 glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1501 expectError(GL_INVALID_OPERATION);
1502 glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1503 expectError(GL_INVALID_OPERATION);
1504 m_log << tcu::TestLog::EndSection;
1505 });
1506 ES3F_ADD_API_CASE(uniform_matrixfv_incompatible_type, "Invalid glUniformMatrix{234}fv() usage",
1507 {
1508 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1509
1510 glUseProgram (program.getProgram());
1511 GLint mat4_v = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1512 GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1513 expectError(GL_NO_ERROR);
1514
1515 if (mat4_v == -1 || sampler_f == -1)
1516 {
1517 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1518 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1519 }
1520
1521 std::vector<GLfloat> data(16);
1522
1523 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the glUniform command.");
1524 glUseProgram(program.getProgram());
1525 glUniformMatrix2fv(mat4_v, 1, GL_FALSE, &data[0]);
1526 expectError(GL_INVALID_OPERATION);
1527 glUniformMatrix3fv(mat4_v, 1, GL_FALSE, &data[0]);
1528 expectError(GL_INVALID_OPERATION);
1529 glUniformMatrix4fv(mat4_v, 1, GL_FALSE, &data[0]);
1530 expectError(GL_NO_ERROR);
1531
1532 glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1533 expectError(GL_INVALID_OPERATION);
1534 glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1535 expectError(GL_INVALID_OPERATION);
1536 glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1537 expectError(GL_INVALID_OPERATION);
1538 glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1539 expectError(GL_INVALID_OPERATION);
1540 glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1541 expectError(GL_INVALID_OPERATION);
1542 glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1543 expectError(GL_INVALID_OPERATION);
1544 m_log << tcu::TestLog::EndSection;
1545
1546 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than glUniform1i and glUniform1iv.");
1547 glUseProgram(program.getProgram());
1548 glUniformMatrix2fv(sampler_f, 1, GL_FALSE, &data[0]);
1549 expectError(GL_INVALID_OPERATION);
1550 glUniformMatrix3fv(sampler_f, 1, GL_FALSE, &data[0]);
1551 expectError(GL_INVALID_OPERATION);
1552 glUniformMatrix4fv(sampler_f, 1, GL_FALSE, &data[0]);
1553 expectError(GL_INVALID_OPERATION);
1554
1555 glUniformMatrix2x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1556 expectError(GL_INVALID_OPERATION);
1557 glUniformMatrix3x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1558 expectError(GL_INVALID_OPERATION);
1559 glUniformMatrix2x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1560 expectError(GL_INVALID_OPERATION);
1561 glUniformMatrix4x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1562 expectError(GL_INVALID_OPERATION);
1563 glUniformMatrix3x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1564 expectError(GL_INVALID_OPERATION);
1565 glUniformMatrix4x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1566 expectError(GL_INVALID_OPERATION);
1567 m_log << tcu::TestLog::EndSection;
1568
1569 glUseProgram(0);
1570 });
1571 ES3F_ADD_API_CASE(uniform_matrixfv_invalid_location, "Invalid glUniformMatrix{234}fv() usage",
1572 {
1573 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1574
1575 glUseProgram(program.getProgram());
1576 expectError(GL_NO_ERROR);
1577
1578 std::vector<GLfloat> data(16);
1579
1580 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1581 glUseProgram(program.getProgram());
1582 glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
1583 expectError(GL_INVALID_OPERATION);
1584 glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
1585 expectError(GL_INVALID_OPERATION);
1586 glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
1587 expectError(GL_INVALID_OPERATION);
1588
1589 glUniformMatrix2x3fv(-2, 1, GL_FALSE, &data[0]);
1590 expectError(GL_INVALID_OPERATION);
1591 glUniformMatrix3x2fv(-2, 1, GL_FALSE, &data[0]);
1592 expectError(GL_INVALID_OPERATION);
1593 glUniformMatrix2x4fv(-2, 1, GL_FALSE, &data[0]);
1594 expectError(GL_INVALID_OPERATION);
1595 glUniformMatrix4x2fv(-2, 1, GL_FALSE, &data[0]);
1596 expectError(GL_INVALID_OPERATION);
1597 glUniformMatrix3x4fv(-2, 1, GL_FALSE, &data[0]);
1598 expectError(GL_INVALID_OPERATION);
1599 glUniformMatrix4x3fv(-2, 1, GL_FALSE, &data[0]);
1600 expectError(GL_INVALID_OPERATION);
1601
1602 glUseProgram(program.getProgram());
1603 glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1604 expectError(GL_NO_ERROR);
1605 glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1606 expectError(GL_NO_ERROR);
1607 glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1608 expectError(GL_NO_ERROR);
1609
1610 glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1611 expectError(GL_NO_ERROR);
1612 glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1613 expectError(GL_NO_ERROR);
1614 glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1615 expectError(GL_NO_ERROR);
1616 glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1617 expectError(GL_NO_ERROR);
1618 glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1619 expectError(GL_NO_ERROR);
1620 glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1621 expectError(GL_NO_ERROR);
1622 m_log << tcu::TestLog::EndSection;
1623
1624 glUseProgram(0);
1625 });
1626 ES3F_ADD_API_CASE(uniform_matrixfv_invalid_count, "Invalid glUniformMatrix{234}fv() usage",
1627 {
1628 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1629
1630 glUseProgram (program.getProgram());
1631 GLint mat4_v = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1632 expectError(GL_NO_ERROR);
1633
1634 if (mat4_v == -1)
1635 {
1636 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1637 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
1638 }
1639
1640 std::vector<GLfloat> data(32);
1641
1642 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1643 glUseProgram(program.getProgram());
1644 glUniformMatrix2fv(mat4_v, 2, GL_FALSE, &data[0]);
1645 expectError(GL_INVALID_OPERATION);
1646 glUniformMatrix3fv(mat4_v, 2, GL_FALSE, &data[0]);
1647 expectError(GL_INVALID_OPERATION);
1648 glUniformMatrix4fv(mat4_v, 2, GL_FALSE, &data[0]);
1649 expectError(GL_INVALID_OPERATION);
1650
1651 glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1652 expectError(GL_INVALID_OPERATION);
1653 glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1654 expectError(GL_INVALID_OPERATION);
1655 glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1656 expectError(GL_INVALID_OPERATION);
1657 glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1658 expectError(GL_INVALID_OPERATION);
1659 glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1660 expectError(GL_INVALID_OPERATION);
1661 glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1662 expectError(GL_INVALID_OPERATION);
1663 m_log << tcu::TestLog::EndSection;
1664
1665 glUseProgram(0);
1666 });
1667
1668 // Transform feedback
1669
1670 ES3F_ADD_API_CASE(gen_transform_feedbacks, "Invalid glGenTransformFeedbacks() usage",
1671 {
1672 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1673 GLuint id;
1674 glGenTransformFeedbacks(-1, &id);
1675 expectError(GL_INVALID_VALUE);
1676 m_log << tcu::TestLog::EndSection;
1677 });
1678 ES3F_ADD_API_CASE(bind_transform_feedback, "Invalid glBindTransformFeedback() usage",
1679 {
1680 GLuint tfID[2];
1681 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1682 deUint32 buf;
1683 const char* tfVarying = "gl_Position";
1684
1685 glGenBuffers (1, &buf);
1686 glGenTransformFeedbacks (2, tfID);
1687
1688 m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK.");
1689 glBindTransformFeedback(-1, tfID[0]);
1690 expectError(GL_INVALID_ENUM);
1691 m_log << tcu::TestLog::EndSection;
1692
1693 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the transform feedback operation is active on the currently bound transform feedback object, and is not paused.");
1694 glUseProgram (program.getProgram());
1695 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1696 glLinkProgram (program.getProgram());
1697 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
1698 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1699 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1700 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1701 glBeginTransformFeedback (GL_TRIANGLES);
1702 expectError (GL_NO_ERROR);
1703
1704 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[1]);
1705 expectError (GL_INVALID_OPERATION);
1706
1707 glEndTransformFeedback ();
1708 expectError (GL_NO_ERROR);
1709 m_log << tcu::TestLog::EndSection;
1710
1711 glUseProgram (0);
1712 glDeleteBuffers (1, &buf);
1713 glDeleteTransformFeedbacks (2, tfID);
1714 expectError (GL_NO_ERROR);
1715 });
1716 ES3F_ADD_API_CASE(delete_transform_feedbacks, "Invalid glDeleteTransformFeedbacks() usage",
1717 {
1718 GLuint id;
1719 glGenTransformFeedbacks(1, &id);
1720
1721 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1722 glDeleteTransformFeedbacks(-1, &id);
1723 expectError(GL_INVALID_VALUE);
1724 m_log << tcu::TestLog::EndSection;
1725
1726 glDeleteTransformFeedbacks(1, &id);
1727 });
1728 ES3F_ADD_API_CASE(begin_transform_feedback, "Invalid glBeginTransformFeedback() usage",
1729 {
1730 GLuint tfID[2];
1731 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1732 deUint32 buf;
1733 const char* tfVarying = "gl_Position";
1734
1735 glGenBuffers (1, &buf);
1736 glGenTransformFeedbacks (2, tfID);
1737
1738 glUseProgram (program.getProgram());
1739 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1740 glLinkProgram (program.getProgram());
1741 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
1742 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1743 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1744 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1745 expectError (GL_NO_ERROR);
1746
1747 m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if primitiveMode is not one of GL_POINTS, GL_LINES, or GL_TRIANGLES.");
1748 glBeginTransformFeedback (-1);
1749 expectError (GL_INVALID_ENUM);
1750 m_log << tcu::TestLog::EndSection;
1751
1752 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is already active.");
1753 glBeginTransformFeedback (GL_TRIANGLES);
1754 expectError (GL_NO_ERROR);
1755 glBeginTransformFeedback (GL_POINTS);
1756 expectError (GL_INVALID_OPERATION);
1757 m_log << tcu::TestLog::EndSection;
1758
1759 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if any binding point used in transform feedback mode does not have a buffer object bound.");
1760 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
1761 glBeginTransformFeedback (GL_TRIANGLES);
1762 expectError (GL_INVALID_OPERATION);
1763 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1764 m_log << tcu::TestLog::EndSection;
1765
1766 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if no binding points would be used because no program object is active.");
1767 glUseProgram (0);
1768 glBeginTransformFeedback (GL_TRIANGLES);
1769 expectError (GL_INVALID_OPERATION);
1770 glUseProgram (program.getProgram());
1771 m_log << tcu::TestLog::EndSection;
1772
1773 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if no binding points would be used because the active program object has specified no varying variables to record.");
1774 glTransformFeedbackVaryings (program.getProgram(), 0, 0, GL_INTERLEAVED_ATTRIBS);
1775 glBeginTransformFeedback (GL_TRIANGLES);
1776 expectError (GL_INVALID_OPERATION);
1777 m_log << tcu::TestLog::EndSection;
1778
1779 glEndTransformFeedback ();
1780 glDeleteBuffers (1, &buf);
1781 glDeleteTransformFeedbacks (2, tfID);
1782 expectError (GL_NO_ERROR);
1783 });
1784 ES3F_ADD_API_CASE(pause_transform_feedback, "Invalid glPauseTransformFeedback() usage",
1785 {
1786 GLuint tfID[2];
1787 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1788 deUint32 buf;
1789 const char* tfVarying = "gl_Position";
1790
1791 glGenBuffers (1, &buf);
1792 glGenTransformFeedbacks (2, tfID);
1793
1794 glUseProgram (program.getProgram());
1795 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1796 glLinkProgram (program.getProgram());
1797 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
1798 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1799 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1800 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1801 expectError (GL_NO_ERROR);
1802
1803 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is paused.");
1804 glPauseTransformFeedback ();
1805 expectError (GL_INVALID_OPERATION);
1806 glBeginTransformFeedback (GL_TRIANGLES);
1807 glPauseTransformFeedback ();
1808 expectError (GL_NO_ERROR);
1809 glPauseTransformFeedback ();
1810 expectError (GL_INVALID_OPERATION);
1811 m_log << tcu::TestLog::EndSection;
1812
1813 glEndTransformFeedback ();
1814 glDeleteBuffers (1, &buf);
1815 glDeleteTransformFeedbacks (2, tfID);
1816 expectError (GL_NO_ERROR);
1817 });
1818 ES3F_ADD_API_CASE(resume_transform_feedback, "Invalid glResumeTransformFeedback() usage",
1819 {
1820 GLuint tfID[2];
1821 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1822 deUint32 buf;
1823 const char* tfVarying = "gl_Position";
1824
1825 glGenBuffers (1, &buf);
1826 glGenTransformFeedbacks (2, tfID);
1827
1828 glUseProgram (program.getProgram());
1829 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1830 glLinkProgram (program.getProgram());
1831 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
1832 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1833 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1834 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1835 expectError (GL_NO_ERROR);
1836
1837 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is not paused.");
1838 glResumeTransformFeedback ();
1839 expectError (GL_INVALID_OPERATION);
1840 glBeginTransformFeedback (GL_TRIANGLES);
1841 glResumeTransformFeedback ();
1842 expectError (GL_INVALID_OPERATION);
1843 glPauseTransformFeedback ();
1844 glResumeTransformFeedback ();
1845 expectError (GL_NO_ERROR);
1846 m_log << tcu::TestLog::EndSection;
1847
1848 glEndTransformFeedback ();
1849 glDeleteBuffers (1, &buf);
1850 glDeleteTransformFeedbacks (2, tfID);
1851 expectError (GL_NO_ERROR);
1852 });
1853 ES3F_ADD_API_CASE(end_transform_feedback, "Invalid glEndTransformFeedback() usage",
1854 {
1855 GLuint tfID;
1856 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1857 deUint32 buf;
1858 const char* tfVarying = "gl_Position";
1859
1860 glGenBuffers (1, &buf);
1861 glGenTransformFeedbacks (1, &tfID);
1862
1863 glUseProgram (program.getProgram());
1864 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1865 glLinkProgram (program.getProgram());
1866 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
1867 glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1868 glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1869 glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1870 expectError (GL_NO_ERROR);
1871
1872 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is not active.");
1873 glEndTransformFeedback ();
1874 expectError (GL_INVALID_OPERATION);
1875 glBeginTransformFeedback (GL_TRIANGLES);
1876 glEndTransformFeedback ();
1877 expectError (GL_NO_ERROR);
1878 m_log << tcu::TestLog::EndSection;
1879
1880 glDeleteBuffers (1, &buf);
1881 glDeleteTransformFeedbacks (1, &tfID);
1882 expectError (GL_NO_ERROR);
1883 });
1884 ES3F_ADD_API_CASE(get_transform_feedback_varying, "Invalid glGetTransformFeedbackVarying() usage",
1885 {
1886 GLuint tfID;
1887 glu::ShaderProgram program (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1888 glu::ShaderProgram programInvalid (m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
1889 const char* tfVarying = "gl_Position";
1890 int maxTransformFeedbackVaryings = 0;
1891
1892 GLsizei length;
1893 GLsizei size;
1894 GLenum type;
1895 char name[32];
1896
1897 glGenTransformFeedbacks (1, &tfID);
1898
1899 glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1900 expectError (GL_NO_ERROR);
1901 glLinkProgram (program.getProgram());
1902 expectError (GL_NO_ERROR);
1903
1904 glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
1905 expectError (GL_NO_ERROR);
1906
1907 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object.");
1908 glGetTransformFeedbackVarying (-1, 0, 32, &length, &size, &type, &name[0]);
1909 expectError (GL_INVALID_VALUE);
1910 m_log << tcu::TestLog::EndSection;
1911
1912 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater or equal to the value of GL_TRANSFORM_FEEDBACK_VARYINGS.");
1913 glGetProgramiv (program.getProgram(), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxTransformFeedbackVaryings);
1914 glGetTransformFeedbackVarying (program.getProgram(), maxTransformFeedbackVaryings, 32, &length, &size, &type, &name[0]);
1915 expectError (GL_INVALID_VALUE);
1916 m_log << tcu::TestLog::EndSection;
1917
1918 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION or GL_INVALID_VALUE is generated program has not been linked.");
1919 glGetTransformFeedbackVarying (programInvalid.getProgram(), 0, 32, &length, &size, &type, &name[0]);
1920 expectError (GL_INVALID_OPERATION, GL_INVALID_VALUE);
1921 m_log << tcu::TestLog::EndSection;
1922
1923 glDeleteTransformFeedbacks (1, &tfID);
1924 expectError (GL_NO_ERROR);
1925 });
1926 ES3F_ADD_API_CASE(transform_feedback_varyings, "Invalid glTransformFeedbackVaryings() usage",
1927 {
1928 GLuint tfID;
1929 glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1930 const char* tfVarying = "gl_Position";
1931 GLint maxTransformFeedbackSeparateAttribs = 0;
1932
1933 glGenTransformFeedbacks (1, &tfID);
1934 expectError (GL_NO_ERROR);
1935
1936 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if program is not the name of a program object.");
1937 glTransformFeedbackVaryings (0, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1938 expectError (GL_INVALID_VALUE);
1939 m_log << tcu::TestLog::EndSection;
1940
1941 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
1942 glGetIntegerv (GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
1943 glTransformFeedbackVaryings (program.getProgram(), maxTransformFeedbackSeparateAttribs+1, &tfVarying, GL_SEPARATE_ATTRIBS);
1944 expectError (GL_INVALID_VALUE);
1945 m_log << tcu::TestLog::EndSection;
1946
1947 glDeleteTransformFeedbacks (1, &tfID);
1948 expectError (GL_NO_ERROR);
1949 });
1950 }
1951
1952 } // Functional
1953 } // gles3
1954 } // deqp
1955