1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.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 "es2fNegativeShaderApiTests.hpp"
25 #include "es2fApiCase.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "gluContextInfo.hpp"
28
29 #include "glwDefs.hpp"
30 #include "glwEnums.hpp"
31
32 #include "deStringUtil.hpp"
33
34 using namespace glw; // GL types
35
36 namespace deqp
37 {
38 namespace gles2
39 {
40 namespace Functional
41 {
42
43 static const char *vertexShaderSource = "void main (void) { gl_Position = vec4(0.0); }\n\0";
44 static const char *fragmentShaderSource = "void main (void) { gl_FragColor = vec4(0.0); }\n\0";
45
46 static const char *uniformTestVertSource = "uniform mediump vec4 vTest;\n"
47 "uniform mediump mat4 vMatrix;\n"
48 "void main (void)\n"
49 "{\n"
50 " gl_Position = vMatrix * vTest;\n"
51 "}\n\0";
52 static const char *uniformTestFragSource = "uniform mediump ivec4 fTest;\n"
53 "uniform sampler2D fSampler;\n"
54 "void main (void)\n"
55 "{\n"
56 " gl_FragColor.xy = vec4(fTest).xy;\n"
57 " gl_FragColor.zw = texture2D(fSampler, vec2(0.0, 0.0)).zw;\n"
58 "}\n\0";
59
60 using tcu::TestLog;
61
NegativeShaderApiTests(Context & context)62 NegativeShaderApiTests::NegativeShaderApiTests(Context &context)
63 : TestCaseGroup(context, "shader", "Negative Shader API Cases")
64 {
65 }
66
~NegativeShaderApiTests(void)67 NegativeShaderApiTests::~NegativeShaderApiTests(void)
68 {
69 }
70
init(void)71 void NegativeShaderApiTests::init(void)
72 {
73 ES2F_ADD_API_CASE(create_shader, "Invalid glCreateShader() usage", {
74 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
75 glCreateShader(-1);
76 expectError(GL_INVALID_ENUM);
77 m_log << TestLog::EndSection;
78 });
79 ES2F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage", {
80 GLboolean shaderCompilerSupported;
81 glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
82 if (!shaderCompilerSupported)
83 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION"
84 << TestLog::EndMessage;
85 else
86 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
87
88 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
89 glShaderSource(1, 0, 0, 0);
90 expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
91 m_log << TestLog::EndSection;
92
93 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if count is less than 0.");
94 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
95 glShaderSource(shader, -1, 0, 0);
96 expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
97 m_log << TestLog::EndSection;
98
99 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
100 GLuint program = glCreateProgram();
101 glShaderSource(program, 0, 0, 0);
102 expectError(GL_INVALID_OPERATION);
103 m_log << TestLog::EndSection;
104
105 glDeleteProgram(program);
106 glDeleteShader(shader);
107 });
108 ES2F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage", {
109 GLboolean shaderCompilerSupported;
110 glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
111 if (!shaderCompilerSupported)
112 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION"
113 << TestLog::EndMessage;
114 else
115 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
116
117 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
118 glCompileShader(9);
119 expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
120 m_log << TestLog::EndSection;
121
122 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
123 GLuint program = glCreateProgram();
124 glCompileShader(program);
125 expectError(GL_INVALID_OPERATION);
126 m_log << TestLog::EndSection;
127
128 glDeleteProgram(program);
129 });
130 ES2F_ADD_API_CASE(delete_shader, "Invalid glDeleteShader() usage", {
131 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
132 glDeleteShader(9);
133 expectError(GL_INVALID_VALUE);
134 m_log << TestLog::EndSection;
135 });
136 ES2F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage", {
137 std::vector<int32_t> binaryFormats;
138 getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
139 bool shaderBinarySupported = !binaryFormats.empty();
140 if (!shaderBinarySupported)
141 m_log << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
142 else
143 m_log << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
144
145 GLuint shaders[2];
146
147 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
148 shaders[1] = glCreateShader(GL_VERTEX_SHADER);
149 GLuint program = glCreateProgram();
150
151 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryformat is not a supported format returned "
152 "in GL_SHADER_BINARY_FORMATS.");
153 glShaderBinary(1, &shaders[0], -1, 0, 0);
154 expectError(GL_INVALID_ENUM);
155 m_log << TestLog::EndSection;
156
157 if (shaderBinarySupported)
158 {
159 m_log << TestLog::Section(
160 "", "GL_INVALID_VALUE is generated if any value in shaders is not a value generated by OpenGL.");
161 shaders[0] = 137;
162 glShaderBinary(1, &shaders[0], binaryFormats[0], 0, 0);
163 expectError(shaderBinarySupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
164 m_log << TestLog::EndSection;
165
166 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n or length is negative.");
167 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
168 glShaderBinary(-1, &shaders[0], binaryFormats[0], 0, 0);
169 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
170 glShaderBinary(1, &shaders[0], binaryFormats[0], 0, -1);
171 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
172 m_log << TestLog::EndSection;
173
174 m_log << TestLog::Section(
175 "", "GL_INVALID_OPERATION is generated if any value in shaders is not a shader object.");
176 glShaderBinary(1, &program, binaryFormats[0], 0, 0);
177 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
178 m_log << TestLog::EndSection;
179
180 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if there is more than one vertex shader "
181 "object handle or more than one fragment shader object handle in shaders.");
182 shaders[0] = glCreateShader(GL_VERTEX_SHADER);
183 shaders[1] = glCreateShader(GL_VERTEX_SHADER);
184 glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 1);
185 expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
186 m_log << TestLog::EndSection;
187 }
188
189 glDeleteShader(shaders[0]);
190 glDeleteShader(shaders[1]);
191 glDeleteProgram(program);
192
193 // \note: The format of the data pointed to by binary does not match binaryformat.
194 });
195 ES2F_ADD_API_CASE(attach_shader, "Invalid glAttachShader() usage", {
196 GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
197 GLuint shader2 = glCreateShader(GL_VERTEX_SHADER);
198 GLuint program = glCreateProgram();
199
200 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
201 glAttachShader(shader1, shader1);
202 expectError(GL_INVALID_OPERATION);
203 m_log << TestLog::EndSection;
204
205 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
206 glAttachShader(program, program);
207 expectError(GL_INVALID_OPERATION);
208 glAttachShader(shader1, program);
209 expectError(GL_INVALID_OPERATION);
210 m_log << TestLog::EndSection;
211
212 m_log << TestLog::Section(
213 "", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
214 glAttachShader(program, -1);
215 expectError(GL_INVALID_VALUE);
216 glAttachShader(-1, shader1);
217 expectError(GL_INVALID_VALUE);
218 glAttachShader(-1, -1);
219 expectError(GL_INVALID_VALUE);
220 m_log << TestLog::EndSection;
221
222 m_log << TestLog::Section("",
223 "GL_INVALID_OPERATION is generated if shader is already attached to program, or if "
224 "another shader object of the same type as shader is already attached to program.");
225 glAttachShader(program, shader1);
226 expectError(GL_NO_ERROR);
227 glAttachShader(program, shader1);
228 expectError(GL_INVALID_OPERATION);
229 glAttachShader(program, shader2);
230 expectError(GL_INVALID_OPERATION);
231 m_log << TestLog::EndSection;
232
233 glDeleteProgram(program);
234 glDeleteShader(shader1);
235 glDeleteShader(shader2);
236 });
237 ES2F_ADD_API_CASE(detach_shader, "Invalid glDetachShader() usage", {
238 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
239 GLuint program = glCreateProgram();
240
241 m_log << TestLog::Section(
242 "", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
243 glDetachShader(-1, shader);
244 expectError(GL_INVALID_VALUE);
245 glDetachShader(program, -1);
246 expectError(GL_INVALID_VALUE);
247 glDetachShader(-1, -1);
248 expectError(GL_INVALID_VALUE);
249 m_log << TestLog::EndSection;
250
251 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
252 glDetachShader(shader, shader);
253 expectError(GL_INVALID_OPERATION);
254 m_log << TestLog::EndSection;
255
256 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
257 glDetachShader(program, program);
258 expectError(GL_INVALID_OPERATION);
259 glDetachShader(shader, program);
260 expectError(GL_INVALID_OPERATION);
261 m_log << TestLog::EndSection;
262
263 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not attached to program.");
264 glDetachShader(program, shader);
265 expectError(GL_INVALID_OPERATION);
266 m_log << TestLog::EndSection;
267
268 glDeleteProgram(program);
269 glDeleteShader(shader);
270 });
271 ES2F_ADD_API_CASE(link_program, "Invalid glLinkProgram() usage", {
272 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
273
274 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
275 glLinkProgram(-1);
276 expectError(GL_INVALID_VALUE);
277 m_log << TestLog::EndSection;
278
279 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
280 glLinkProgram(shader);
281 expectError(GL_INVALID_OPERATION);
282 m_log << TestLog::EndSection;
283
284 glDeleteShader(shader);
285 });
286 ES2F_ADD_API_CASE(use_program, "Invalid glUseProgram() usage", {
287 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
288
289 m_log << TestLog::Section(
290 "", "GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
291 glUseProgram(-1);
292 expectError(GL_INVALID_VALUE);
293 m_log << TestLog::EndSection;
294
295 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
296 glUseProgram(shader);
297 expectError(GL_INVALID_OPERATION);
298 m_log << TestLog::EndSection;
299
300 glUseProgram(0);
301 glDeleteShader(shader);
302 });
303 ES2F_ADD_API_CASE(delete_program, "Invalid glDeleteProgram() usage", {
304 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
305 glDeleteProgram(-1);
306 expectError(GL_INVALID_VALUE);
307 m_log << TestLog::EndSection;
308 });
309 ES2F_ADD_API_CASE(get_active_attrib, "Invalid glGetActiveAttrib() usage", {
310 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
311 glu::ShaderProgram program(m_context.getRenderContext(),
312 glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
313 glUseProgram(program.getProgram());
314
315 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
316 glGetActiveAttrib(-1, 0, 0, 0, 0, 0, 0);
317 expectError(GL_INVALID_VALUE);
318 m_log << TestLog::EndSection;
319
320 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
321 glGetActiveAttrib(shader, 0, 0, 0, 0, 0, 0);
322 expectError(GL_INVALID_OPERATION);
323 m_log << TestLog::EndSection;
324
325 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number "
326 "of active attribute variables in program.");
327 glGetActiveAttrib(program.getProgram(), 0, 0, 0, 0, 0, 0);
328 expectError(GL_INVALID_VALUE);
329 m_log << TestLog::EndSection;
330
331 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
332 glGetActiveAttrib(program.getProgram(), 0, -1, 0, 0, 0, 0);
333 expectError(GL_INVALID_VALUE);
334 m_log << TestLog::EndSection;
335
336 glUseProgram(0);
337 glDeleteShader(shader);
338 });
339 ES2F_ADD_API_CASE(get_attrib_location, "Invalid glGetAttribLocation() usage", {
340 GLuint programEmpty = glCreateProgram();
341 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
342 glu::ShaderProgram program(m_context.getRenderContext(),
343 glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
344
345 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
346 glBindAttribLocation(programEmpty, 0, "test");
347 glGetAttribLocation(programEmpty, "test");
348 expectError(GL_INVALID_OPERATION);
349 m_log << TestLog::EndSection;
350
351 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a program or shader object.");
352 glUseProgram(program.getProgram());
353 glBindAttribLocation(program.getProgram(), 0, "test");
354 expectError(GL_NO_ERROR);
355 glGetAttribLocation(program.getProgram(), "test");
356 expectError(GL_NO_ERROR);
357 glGetAttribLocation(-2, "test");
358 expectError(GL_INVALID_VALUE);
359 m_log << TestLog::EndSection;
360
361 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
362 glGetAttribLocation(shader, "test");
363 expectError(GL_INVALID_OPERATION);
364 m_log << TestLog::EndSection;
365
366 glUseProgram(0);
367 glDeleteShader(shader);
368 glDeleteProgram(programEmpty);
369 });
370 ES2F_ADD_API_CASE(get_uniform_location, "Invalid glGetUniformLocation() usage", {
371 GLuint programEmpty = glCreateProgram();
372 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
373 glu::ShaderProgram program(m_context.getRenderContext(),
374 glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
375
376 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
377 glGetUniformLocation(programEmpty, "test");
378 expectError(GL_INVALID_OPERATION);
379 m_log << TestLog::EndSection;
380
381 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
382 glUseProgram(program.getProgram());
383 glGetUniformLocation(-2, "test");
384 expectError(GL_INVALID_VALUE);
385 m_log << TestLog::EndSection;
386
387 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
388 glGetAttribLocation(shader, "test");
389 expectError(GL_INVALID_OPERATION);
390 m_log << TestLog::EndSection;
391
392 glUseProgram(0);
393 glDeleteProgram(programEmpty);
394 glDeleteShader(shader);
395 });
396 ES2F_ADD_API_CASE(bind_attrib_location, "Invalid glBindAttribLocation() usage", {
397 GLuint program = glCreateProgram();
398 GLuint maxIndex = m_context.getContextInfo().getInt(GL_MAX_VERTEX_ATTRIBS);
399 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
400
401 m_log << TestLog::Section(
402 "", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
403 glBindAttribLocation(program, maxIndex, "test");
404 expectError(GL_INVALID_VALUE);
405 m_log << TestLog::EndSection;
406
407 m_log << TestLog::Section("",
408 "GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
409 glBindAttribLocation(program, maxIndex - 1, "gl_test");
410 expectError(GL_INVALID_OPERATION);
411 m_log << TestLog::EndSection;
412
413 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
414 glBindAttribLocation(-1, maxIndex - 1, "test");
415 expectError(GL_INVALID_VALUE);
416 m_log << TestLog::EndSection;
417
418 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
419 glBindAttribLocation(shader, maxIndex - 1, "test");
420 expectError(GL_INVALID_OPERATION);
421 m_log << TestLog::EndSection;
422
423 glDeleteProgram(program);
424 glDeleteShader(shader);
425 });
426 ES2F_ADD_API_CASE(get_active_uniform, "Invalid glGetActiveUniform() usage", {
427 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
428 glu::ShaderProgram program(m_context.getRenderContext(),
429 glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
430
431 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
432 glGetActiveUniform(-1, 0, 0, 0, 0, 0, 0);
433 expectError(GL_INVALID_VALUE);
434 m_log << TestLog::EndSection;
435
436 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
437 glGetActiveUniform(shader, 0, 0, 0, 0, 0, 0);
438 expectError(GL_INVALID_OPERATION);
439 m_log << TestLog::EndSection;
440
441 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number "
442 "of active attribute variables in program.");
443 glUseProgram(program.getProgram());
444 glGetActiveUniform(program.getProgram(), 5, 0, 0, 0, 0, 0);
445 expectError(GL_INVALID_VALUE);
446 m_log << TestLog::EndSection;
447
448 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
449 glGetActiveUniform(program.getProgram(), 0, -1, 0, 0, 0, 0);
450 expectError(GL_INVALID_VALUE);
451 m_log << TestLog::EndSection;
452
453 glUseProgram(0);
454 glDeleteShader(shader);
455 });
456 ES2F_ADD_API_CASE(validate_program, "Invalid glValidateProgram() usage", {
457 GLuint shader = glCreateShader(GL_VERTEX_SHADER);
458
459 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
460 glValidateProgram(-1);
461 expectError(GL_INVALID_VALUE);
462 m_log << TestLog::EndSection;
463
464 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
465 glValidateProgram(shader);
466 expectError(GL_INVALID_OPERATION);
467 m_log << TestLog::EndSection;
468
469 glDeleteShader(shader);
470 });
471
472 ES2F_ADD_API_CASE(release_shader_compiler, "Invalid glReleaseShaderCompiler() usage", {
473 GLboolean shaderCompilerSupported;
474 glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
475
476 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader compiler is not supported.");
477 glReleaseShaderCompiler();
478 expectError(shaderCompilerSupported ? GL_NONE : GL_INVALID_OPERATION);
479 m_log << TestLog::EndSection;
480 });
481
482 // glUniform*f
483
484 ES2F_ADD_API_CASE(uniformf_invalid_program, "Invalid glUniform{1234}f() usage", {
485 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
486 glUseProgram(0);
487 glUniform1f(-1, 0.0f);
488 expectError(GL_INVALID_OPERATION);
489 glUniform2f(-1, 0.0f, 0.0f);
490 expectError(GL_INVALID_OPERATION);
491 glUniform3f(-1, 0.0f, 0.0f, 0.0f);
492 expectError(GL_INVALID_OPERATION);
493 glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
494 expectError(GL_INVALID_OPERATION);
495 m_log << tcu::TestLog::EndSection;
496 });
497 ES2F_ADD_API_CASE(uniformf_incompatible_type, "Invalid glUniform{1234}f() usage", {
498 glu::ShaderProgram program(m_context.getRenderContext(),
499 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
500 glUseProgram(program.getProgram());
501 GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
502 GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
503 GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
504
505 if (vUnif == -1 || fUnif == -1 || fSampler == -1)
506 {
507 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
508 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
509 }
510
511 m_log << tcu::TestLog::Section("",
512 "GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
513 "in the shader does not match the size indicated by the glUniform command.");
514 glUseProgram(program.getProgram());
515 glUniform1f(vUnif, 0.0f);
516 expectError(GL_INVALID_OPERATION);
517 glUniform2f(vUnif, 0.0f, 0.0f);
518 expectError(GL_INVALID_OPERATION);
519 glUniform3f(vUnif, 0.0f, 0.0f, 0.0f);
520 expectError(GL_INVALID_OPERATION);
521 glUniform4f(vUnif, 0.0f, 0.0f, 0.0f, 0.0f);
522 expectError(GL_NO_ERROR);
523 m_log << tcu::TestLog::EndSection;
524
525 m_log << tcu::TestLog::Section(
526 "", "GL_INVALID_OPERATION is generated if one of the floating-point variants of this function is used to "
527 "load a uniform variable of type int, ivec2, ivec3, or ivec4.");
528 glUseProgram(program.getProgram());
529 glUniform4f(fUnif, 0.0f, 0.0f, 0.0f, 0.0f);
530 expectError(GL_INVALID_OPERATION);
531 m_log << tcu::TestLog::EndSection;
532
533 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
534 "other than glUniform1i and glUniform1iv.");
535 glUseProgram(program.getProgram());
536 glUniform1f(fSampler, 0.0f);
537 expectError(GL_INVALID_OPERATION);
538 m_log << tcu::TestLog::EndSection;
539
540 glUseProgram(0);
541 });
542 ES2F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage", {
543 glu::ShaderProgram program(m_context.getRenderContext(),
544 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
545 glUseProgram(program.getProgram());
546
547 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
548 "location for the current program object and location is not equal to -1.");
549 glUseProgram(program.getProgram());
550 glUniform1f(-2, 0.0f);
551 expectError(GL_INVALID_OPERATION);
552 glUniform2f(-2, 0.0f, 0.0f);
553 expectError(GL_INVALID_OPERATION);
554 glUniform3f(-2, 0.0f, 0.0f, 0.0f);
555 expectError(GL_INVALID_OPERATION);
556 glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
557 expectError(GL_INVALID_OPERATION);
558
559 glUseProgram(program.getProgram());
560 glUniform1f(-1, 0.0f);
561 expectError(GL_NO_ERROR);
562 glUniform2f(-1, 0.0f, 0.0f);
563 expectError(GL_NO_ERROR);
564 glUniform3f(-1, 0.0f, 0.0f, 0.0f);
565 expectError(GL_NO_ERROR);
566 glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
567 expectError(GL_NO_ERROR);
568 m_log << tcu::TestLog::EndSection;
569
570 glUseProgram(0);
571 });
572
573 // glUniform*fv
574
575 ES2F_ADD_API_CASE(uniformfv_invalid_program, "Invalid glUniform{1234}fv() usage", {
576 std::vector<GLfloat> data(4);
577
578 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
579 glUseProgram(0);
580 glUniform1fv(-1, 1, &data[0]);
581 expectError(GL_INVALID_OPERATION);
582 glUniform2fv(-1, 1, &data[0]);
583 expectError(GL_INVALID_OPERATION);
584 glUniform3fv(-1, 1, &data[0]);
585 expectError(GL_INVALID_OPERATION);
586 glUniform4fv(-1, 1, &data[0]);
587 expectError(GL_INVALID_OPERATION);
588 m_log << tcu::TestLog::EndSection;
589 });
590 ES2F_ADD_API_CASE(uniformfv_incompatible_type, "Invalid glUniform{1234}fv() usage", {
591 glu::ShaderProgram program(m_context.getRenderContext(),
592 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
593 glUseProgram(program.getProgram());
594 GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
595 GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
596 GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
597
598 if (vUnif == -1 || fUnif == -1 || fSampler == -1)
599 {
600 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
601 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
602 }
603
604 std::vector<GLfloat> data(4);
605
606 m_log << tcu::TestLog::Section("",
607 "GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
608 "in the shader does not match the size indicated by the glUniform command.");
609 glUseProgram(program.getProgram());
610 glUniform1fv(vUnif, 1, &data[0]);
611 expectError(GL_INVALID_OPERATION);
612 glUniform2fv(vUnif, 1, &data[0]);
613 expectError(GL_INVALID_OPERATION);
614 glUniform3fv(vUnif, 1, &data[0]);
615 expectError(GL_INVALID_OPERATION);
616 glUniform4fv(vUnif, 1, &data[0]);
617 expectError(GL_NO_ERROR);
618 m_log << tcu::TestLog::EndSection;
619
620 m_log << tcu::TestLog::Section(
621 "", "GL_INVALID_OPERATION is generated if one of the floating-point variants of this function is used to "
622 "load a uniform variable of type int, ivec2, ivec3, or ivec4.");
623 glUseProgram(program.getProgram());
624 glUniform4fv(fUnif, 1, &data[0]);
625 expectError(GL_INVALID_OPERATION);
626 m_log << tcu::TestLog::EndSection;
627
628 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
629 "other than glUniform1i and glUniform1iv.");
630 glUseProgram(program.getProgram());
631 glUniform1fv(fSampler, 1, &data[0]);
632 expectError(GL_INVALID_OPERATION);
633 m_log << tcu::TestLog::EndSection;
634
635 glUseProgram(0);
636 });
637 ES2F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage", {
638 glu::ShaderProgram program(m_context.getRenderContext(),
639 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
640 glUseProgram(program.getProgram());
641
642 std::vector<GLfloat> data(4);
643
644 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
645 "location for the current program object and location is not equal to -1.");
646 glUseProgram(program.getProgram());
647 glUniform1fv(-2, 1, &data[0]);
648 expectError(GL_INVALID_OPERATION);
649 glUniform2fv(-2, 1, &data[0]);
650 expectError(GL_INVALID_OPERATION);
651 glUniform3fv(-2, 1, &data[0]);
652 expectError(GL_INVALID_OPERATION);
653 glUniform4fv(-2, 1, &data[0]);
654 expectError(GL_INVALID_OPERATION);
655
656 glUseProgram(program.getProgram());
657 glUniform1fv(-1, 1, &data[0]);
658 expectError(GL_NO_ERROR);
659 glUniform2fv(-1, 1, &data[0]);
660 expectError(GL_NO_ERROR);
661 glUniform3fv(-1, 1, &data[0]);
662 expectError(GL_NO_ERROR);
663 glUniform4fv(-1, 1, &data[0]);
664 expectError(GL_NO_ERROR);
665 m_log << tcu::TestLog::EndSection;
666
667 glUseProgram(0);
668 });
669 ES2F_ADD_API_CASE(uniformfv_invalid_count, "Invalid glUniform{1234}fv() usage", {
670 glu::ShaderProgram program(m_context.getRenderContext(),
671 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
672 glUseProgram(program.getProgram());
673 GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
674
675 if (vUnif == -1)
676 {
677 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
678 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
679 }
680
681 std::vector<GLfloat> data(8);
682
683 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
684 "indicated uniform variable is not an array variable.");
685 glUseProgram(program.getProgram());
686 glUniform1fv(vUnif, 2, &data[0]);
687 expectError(GL_INVALID_OPERATION);
688 glUniform2fv(vUnif, 2, &data[0]);
689 expectError(GL_INVALID_OPERATION);
690 glUniform3fv(vUnif, 2, &data[0]);
691 expectError(GL_INVALID_OPERATION);
692 glUniform4fv(vUnif, 2, &data[0]);
693 expectError(GL_INVALID_OPERATION);
694 m_log << tcu::TestLog::EndSection;
695
696 glUseProgram(0);
697 });
698
699 // glUniform*i
700
701 ES2F_ADD_API_CASE(uniformi_invalid_program, "Invalid glUniform{1234}i() usage", {
702 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
703 glUseProgram(0);
704 glUniform1i(-1, 0);
705 expectError(GL_INVALID_OPERATION);
706 glUniform2i(-1, 0, 0);
707 expectError(GL_INVALID_OPERATION);
708 glUniform3i(-1, 0, 0, 0);
709 expectError(GL_INVALID_OPERATION);
710 glUniform4i(-1, 0, 0, 0, 0);
711 expectError(GL_INVALID_OPERATION);
712 m_log << tcu::TestLog::EndSection;
713 });
714 ES2F_ADD_API_CASE(uniformi_incompatible_type, "Invalid glUniform{1234}i() usage", {
715 glu::ShaderProgram program(m_context.getRenderContext(),
716 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
717 glUseProgram(program.getProgram());
718 GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
719 GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
720 GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
721
722 if (vUnif == -1 || fUnif == -1 || fSampler == -1)
723 {
724 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
725 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
726 }
727
728 m_log << tcu::TestLog::Section("",
729 "GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
730 "in the shader does not match the size indicated by the glUniform command.");
731 glUseProgram(program.getProgram());
732 glUniform1i(fUnif, 0);
733 expectError(GL_INVALID_OPERATION);
734 glUniform2i(fUnif, 0, 0);
735 expectError(GL_INVALID_OPERATION);
736 glUniform3i(fUnif, 0, 0, 0);
737 expectError(GL_INVALID_OPERATION);
738 glUniform4i(fUnif, 0, 0, 0, 0);
739 expectError(GL_NO_ERROR);
740 m_log << tcu::TestLog::EndSection;
741
742 m_log << tcu::TestLog::Section(
743 "", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a "
744 "uniform variable of type float, vec2, vec3, or vec4.");
745 glUseProgram(program.getProgram());
746 glUniform4i(vUnif, 0, 0, 0, 0);
747 expectError(GL_INVALID_OPERATION);
748 m_log << tcu::TestLog::EndSection;
749
750 glUseProgram(0);
751 });
752 ES2F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage", {
753 glu::ShaderProgram program(m_context.getRenderContext(),
754 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
755 glUseProgram(program.getProgram());
756
757 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
758 "location for the current program object and location is not equal to -1.");
759 glUseProgram(program.getProgram());
760 glUniform1i(-2, 0);
761 expectError(GL_INVALID_OPERATION);
762 glUniform2i(-2, 0, 0);
763 expectError(GL_INVALID_OPERATION);
764 glUniform3i(-2, 0, 0, 0);
765 expectError(GL_INVALID_OPERATION);
766 glUniform4i(-2, 0, 0, 0, 0);
767 expectError(GL_INVALID_OPERATION);
768
769 glUseProgram(program.getProgram());
770 glUniform1i(-1, 0);
771 expectError(GL_NO_ERROR);
772 glUniform2i(-1, 0, 0);
773 expectError(GL_NO_ERROR);
774 glUniform3i(-1, 0, 0, 0);
775 expectError(GL_NO_ERROR);
776 glUniform4i(-1, 0, 0, 0, 0);
777 expectError(GL_NO_ERROR);
778 m_log << tcu::TestLog::EndSection;
779
780 glUseProgram(0);
781 });
782
783 // glUniform*iv
784
785 ES2F_ADD_API_CASE(uniformiv_invalid_program, "Invalid glUniform{1234}iv() usage", {
786 std::vector<GLint> data(4);
787
788 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
789 glUseProgram(0);
790 glUniform1iv(-1, 1, &data[0]);
791 expectError(GL_INVALID_OPERATION);
792 glUniform2iv(-1, 1, &data[0]);
793 expectError(GL_INVALID_OPERATION);
794 glUniform3iv(-1, 1, &data[0]);
795 expectError(GL_INVALID_OPERATION);
796 glUniform4iv(-1, 1, &data[0]);
797 expectError(GL_INVALID_OPERATION);
798 m_log << tcu::TestLog::EndSection;
799 });
800 ES2F_ADD_API_CASE(uniformiv_incompatible_type, "Invalid glUniform{1234}iv() usage", {
801 glu::ShaderProgram program(m_context.getRenderContext(),
802 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
803 glUseProgram(program.getProgram());
804 GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
805 GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
806 GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
807
808 if (vUnif == -1 || fUnif == -1 || fSampler == -1)
809 {
810 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
811 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
812 }
813
814 std::vector<GLint> data(4);
815
816 m_log << tcu::TestLog::Section("",
817 "GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
818 "in the shader does not match the size indicated by the glUniform command.");
819 glUseProgram(program.getProgram());
820 glUniform1iv(fUnif, 1, &data[0]);
821 expectError(GL_INVALID_OPERATION);
822 glUniform2iv(fUnif, 1, &data[0]);
823 expectError(GL_INVALID_OPERATION);
824 glUniform3iv(fUnif, 1, &data[0]);
825 expectError(GL_INVALID_OPERATION);
826 glUniform4iv(fUnif, 1, &data[0]);
827 expectError(GL_NO_ERROR);
828 m_log << tcu::TestLog::EndSection;
829
830 m_log << tcu::TestLog::Section(
831 "", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a "
832 "uniform variable of type float, vec2, vec3, or vec4.");
833 glUseProgram(program.getProgram());
834 glUniform4iv(vUnif, 1, &data[0]);
835 expectError(GL_INVALID_OPERATION);
836 m_log << tcu::TestLog::EndSection;
837
838 glUseProgram(0);
839 });
840 ES2F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage", {
841 glu::ShaderProgram program(m_context.getRenderContext(),
842 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
843 glUseProgram(program.getProgram());
844
845 std::vector<GLint> data(4);
846
847 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
848 "location for the current program object and location is not equal to -1.");
849 glUseProgram(program.getProgram());
850 glUniform1iv(-2, 1, &data[0]);
851 expectError(GL_INVALID_OPERATION);
852 glUniform2iv(-2, 1, &data[0]);
853 expectError(GL_INVALID_OPERATION);
854 glUniform3iv(-2, 1, &data[0]);
855 expectError(GL_INVALID_OPERATION);
856 glUniform4iv(-2, 1, &data[0]);
857 expectError(GL_INVALID_OPERATION);
858
859 glUseProgram(program.getProgram());
860 glUniform1iv(-1, 1, &data[0]);
861 expectError(GL_NO_ERROR);
862 glUniform2iv(-1, 1, &data[0]);
863 expectError(GL_NO_ERROR);
864 glUniform3iv(-1, 1, &data[0]);
865 expectError(GL_NO_ERROR);
866 glUniform4iv(-1, 1, &data[0]);
867 expectError(GL_NO_ERROR);
868 m_log << tcu::TestLog::EndSection;
869
870 glUseProgram(0);
871 });
872 ES2F_ADD_API_CASE(uniformiv_invalid_count, "Invalid glUniform{1234}iv() usage", {
873 glu::ShaderProgram program(m_context.getRenderContext(),
874 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
875 glUseProgram(program.getProgram());
876 GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
877
878 if (fUnif == -1)
879 {
880 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
881 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
882 }
883
884 std::vector<GLint> data(8);
885
886 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
887 "indicated uniform variable is not an array variable.");
888 glUseProgram(program.getProgram());
889 glUniform1iv(fUnif, 2, &data[0]);
890 expectError(GL_INVALID_OPERATION);
891 glUniform2iv(fUnif, 2, &data[0]);
892 expectError(GL_INVALID_OPERATION);
893 glUniform3iv(fUnif, 2, &data[0]);
894 expectError(GL_INVALID_OPERATION);
895 glUniform4iv(fUnif, 2, &data[0]);
896 expectError(GL_INVALID_OPERATION);
897 m_log << tcu::TestLog::EndSection;
898
899 glUseProgram(0);
900 });
901
902 // glUniformMatrix*fv
903
904 ES2F_ADD_API_CASE(uniform_matrixfv_invalid_program, "Invalid glUniformMatrix{234}fv() usage", {
905 std::vector<GLfloat> data(16);
906
907 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
908 glUseProgram(0);
909 glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
910 expectError(GL_INVALID_OPERATION);
911 glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
912 expectError(GL_INVALID_OPERATION);
913 glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
914 expectError(GL_INVALID_OPERATION);
915 m_log << tcu::TestLog::EndSection;
916 });
917 ES2F_ADD_API_CASE(uniform_matrixfv_incompatible_type, "Invalid glUniformMatrix{234}fv() usage", {
918 glu::ShaderProgram program(m_context.getRenderContext(),
919 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
920 glUseProgram(program.getProgram());
921 GLint vMatUnif = glGetUniformLocation(program.getProgram(), "vMatrix"); // mat4
922 GLint fSamplerUnif = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
923
924 m_log << program;
925
926 if (vMatUnif == -1 || fSamplerUnif == -1)
927 {
928 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
929 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
930 }
931
932 std::vector<GLfloat> data(16);
933
934 m_log << tcu::TestLog::Section("",
935 "GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
936 "in the shader does not match the size indicated by the glUniform command.");
937 glUseProgram(program.getProgram());
938 glUniformMatrix2fv(vMatUnif, 1, GL_FALSE, &data[0]);
939 expectError(GL_INVALID_OPERATION);
940 glUniformMatrix3fv(vMatUnif, 1, GL_FALSE, &data[0]);
941 expectError(GL_INVALID_OPERATION);
942 glUniformMatrix4fv(vMatUnif, 1, GL_FALSE, &data[0]);
943 expectError(GL_NO_ERROR);
944 m_log << tcu::TestLog::EndSection;
945
946 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
947 "other than glUniform1i and glUniform1iv.");
948 glUseProgram(program.getProgram());
949 glUniformMatrix4fv(fSamplerUnif, 1, GL_FALSE, &data[0]);
950 expectError(GL_INVALID_OPERATION);
951 m_log << tcu::TestLog::EndSection;
952
953 glUseProgram(0);
954 });
955 ES2F_ADD_API_CASE(uniform_matrixfv_invalid_location, "Invalid glUniformMatrix{234}fv() usage", {
956 glu::ShaderProgram program(m_context.getRenderContext(),
957 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
958 glUseProgram(program.getProgram());
959
960 m_log << program;
961
962 std::vector<GLfloat> data(16);
963
964 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
965 "location for the current program object and location is not equal to -1.");
966 glUseProgram(program.getProgram());
967 glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
968 expectError(GL_INVALID_OPERATION);
969 glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
970 expectError(GL_INVALID_OPERATION);
971 glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
972 expectError(GL_INVALID_OPERATION);
973
974 glUseProgram(program.getProgram());
975 glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
976 expectError(GL_NO_ERROR);
977 glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
978 expectError(GL_NO_ERROR);
979 glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
980 expectError(GL_NO_ERROR);
981 m_log << tcu::TestLog::EndSection;
982
983 glUseProgram(0);
984 });
985 ES2F_ADD_API_CASE(uniform_matrixfv_invalid_count, "Invalid glUniformMatrix{234}fv() usage", {
986 glu::ShaderProgram program(m_context.getRenderContext(),
987 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
988 glUseProgram(program.getProgram());
989 GLint vMatUnif = glGetUniformLocation(program.getProgram(), "vMatrix"); // mat4
990
991 m_log << program;
992
993 if (vMatUnif == -1)
994 {
995 m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
996 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
997 }
998
999 std::vector<GLfloat> data(32);
1000
1001 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
1002 "indicated uniform variable is not an array variable.");
1003 glUseProgram(program.getProgram());
1004 glUniformMatrix2fv(vMatUnif, 2, GL_FALSE, &data[0]);
1005 expectError(GL_INVALID_OPERATION);
1006 glUniformMatrix3fv(vMatUnif, 2, GL_FALSE, &data[0]);
1007 expectError(GL_INVALID_OPERATION);
1008 glUniformMatrix4fv(vMatUnif, 2, GL_FALSE, &data[0]);
1009 expectError(GL_INVALID_OPERATION);
1010 m_log << tcu::TestLog::EndSection;
1011
1012 glUseProgram(0);
1013 });
1014 ES2F_ADD_API_CASE(uniform_matrixfv_invalid_transpose, "Invalid glUniformMatrix{234}fv() usage", {
1015 if (de::beginsWith((const char *)glGetString(GL_VERSION), "OpenGL ES 2.0 "))
1016 {
1017 DE_ASSERT(m_context.getRenderContext().getType().getMajorVersion() < 3);
1018 DE_ASSERT(m_context.getRenderContext().getType().getMinorVersion() == 0);
1019 DE_ASSERT(m_context.getRenderContext().getType().getProfile() == glu::PROFILE_ES);
1020
1021 glu::ShaderProgram program(m_context.getRenderContext(),
1022 glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1023 glUseProgram(program.getProgram());
1024
1025 m_log << program;
1026
1027 std::vector<GLfloat> data(16);
1028
1029 m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if transpose is not GL_FALSE.");
1030 glUseProgram(program.getProgram());
1031 glUniformMatrix2fv(0, 1, GL_TRUE, &data[0]);
1032 expectError(GL_INVALID_VALUE);
1033 glUniformMatrix3fv(0, 1, GL_TRUE, &data[0]);
1034 expectError(GL_INVALID_VALUE);
1035 glUniformMatrix4fv(0, 1, GL_TRUE, &data[0]);
1036 expectError(GL_INVALID_VALUE);
1037 m_log << tcu::TestLog::EndSection;
1038
1039 glUseProgram(0);
1040 }
1041 });
1042 }
1043
1044 } // namespace Functional
1045 } // namespace gles2
1046 } // namespace deqp
1047