1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Negative Shader API tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es31fNegativeShaderApiTests.hpp"
25
26 #include "deUniquePtr.hpp"
27
28 #include "glwDefs.hpp"
29 #include "glwEnums.hpp"
30
31 #include "gluShaderProgram.hpp"
32 #include "gluCallLogWrapper.hpp"
33
34 #include "gluContextInfo.hpp"
35 #include "gluRenderContext.hpp"
36
37
38 namespace deqp
39 {
40 namespace gles31
41 {
42 namespace Functional
43 {
44 namespace NegativeTestShared
45 {
46 using tcu::TestLog;
47 using glu::CallLogWrapper;
48 using namespace glw;
49
50 static const char* vertexShaderSource = "#version 300 es\n"
51 "void main (void)\n"
52 "{\n"
53 " gl_Position = vec4(0.0);\n"
54 "}\n\0";
55
56 static const char* fragmentShaderSource = "#version 300 es\n"
57 "layout(location = 0) out mediump vec4 fragColor;"
58 "void main (void)\n"
59 "{\n"
60 " fragColor = vec4(0.0);\n"
61 "}\n\0";
62
63 static const char* uniformTestVertSource = "#version 300 es\n"
64 "uniform mediump vec4 vec4_v;\n"
65 "uniform mediump mat4 mat4_v;\n"
66 "void main (void)\n"
67 "{\n"
68 " gl_Position = mat4_v * vec4_v;\n"
69 "}\n\0";
70
71 static const char* uniformTestFragSource = "#version 300 es\n"
72 "uniform mediump ivec4 ivec4_f;\n"
73 "uniform mediump uvec4 uvec4_f;\n"
74 "uniform sampler2D sampler_f;\n"
75 "layout(location = 0) out mediump vec4 fragColor;"
76 "void main (void)\n"
77 "{\n"
78 " fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n"
79 " fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n"
80 "}\n\0";
81
82 static const char* uniformBlockVertSource = "#version 300 es\n"
83 "layout(shared) uniform Block { lowp float var; };\n"
84 "void main (void)\n"
85 "{\n"
86 " gl_Position = vec4(var);\n"
87 "}\n\0";
88
89
90 // Shader control commands
create_shader(NegativeTestContext & ctx)91 void create_shader (NegativeTestContext& ctx)
92 {
93 ctx.beginSection("GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
94 ctx.glCreateShader(-1);
95 ctx.expectError(GL_INVALID_ENUM);
96 ctx.endSection();
97 }
98
shader_source(NegativeTestContext & ctx)99 void shader_source (NegativeTestContext& ctx)
100 {
101 // make notAShader not a shader id
102 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER);
103 ctx.glDeleteShader(notAShader);
104
105 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
106 ctx.glShaderSource(notAShader, 0, 0, 0);
107 ctx.expectError(GL_INVALID_VALUE);
108 ctx.endSection();
109
110 ctx.beginSection("GL_INVALID_VALUE is generated if count is less than 0.");
111 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
112 ctx.glShaderSource(shader, -1, 0, 0);
113 ctx.expectError(GL_INVALID_VALUE);
114 ctx.endSection();
115
116 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
117 GLuint program = ctx.glCreateProgram();
118 ctx.glShaderSource(program, 0, 0, 0);
119 ctx.expectError(GL_INVALID_OPERATION);
120 ctx.endSection();
121
122 ctx.glDeleteProgram(program);
123 ctx.glDeleteShader(shader);
124 }
125
compile_shader(NegativeTestContext & ctx)126 void compile_shader (NegativeTestContext& ctx)
127 {
128 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER);
129 ctx.glDeleteShader(notAShader);
130
131 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
132 ctx.glCompileShader(notAShader);
133 ctx.expectError(GL_INVALID_VALUE);
134 ctx.endSection();
135
136 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
137 GLuint program = ctx.glCreateProgram();
138 ctx.glCompileShader(program);
139 ctx.expectError(GL_INVALID_OPERATION);
140 ctx.endSection();
141
142 ctx.glDeleteProgram(program);
143 }
144
delete_shader(NegativeTestContext & ctx)145 void delete_shader (NegativeTestContext& ctx)
146 {
147 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER);
148 ctx.glDeleteShader(notAShader);
149
150 ctx.beginSection("GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
151 ctx.glDeleteShader(notAShader);
152 ctx.expectError(GL_INVALID_VALUE);
153 ctx.endSection();
154 }
155
shader_binary(NegativeTestContext & ctx)156 void shader_binary (NegativeTestContext& ctx)
157 {
158 std::vector<deInt32> binaryFormats;
159 deBool shaderBinarySupported = !binaryFormats.empty();
160 GLuint shaders[2];
161 GLuint shaderPair[2];
162 GLuint nonProgram[2];
163 GLuint shaderProgram[2];
164
165 {
166 deInt32 numFormats = 0x1234;
167 ctx.glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &numFormats);
168
169 if (numFormats == 0)
170 ctx.getLog() << TestLog::Message << "// No supported extensions available." << TestLog::EndMessage;
171 else
172 {
173 binaryFormats.resize(numFormats);
174 ctx.glGetIntegerv(GL_SHADER_BINARY_FORMATS, &binaryFormats[0]);
175 }
176 }
177
178 if (!shaderBinarySupported)
179 ctx.getLog() << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
180 else
181 ctx.getLog() << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
182
183 shaders[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
184 shaders[1] = ctx.glCreateShader(GL_VERTEX_SHADER);
185 shaderPair[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
186 shaderPair[1] = ctx.glCreateShader(GL_FRAGMENT_SHADER);
187 nonProgram[0] = -1;
188 nonProgram[1] = -1;
189 shaderProgram[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
190 shaderProgram[1] = ctx.glCreateProgram();
191
192 ctx.beginSection("GL_INVALID_ENUM is generated if binaryFormat is not an accepted value.");
193 ctx.glShaderBinary(1, &shaders[0], -1, 0, 0);
194 ctx.expectError(GL_INVALID_ENUM);
195 ctx.endSection();
196
197 if (shaderBinarySupported)
198 {
199 ctx.beginSection("GL_INVALID_VALUE is generated if the data pointed to by binary does not match the format specified by binaryFormat.");
200 const GLbyte data = 0x005F;
201 ctx.glShaderBinary(1, &shaders[0], binaryFormats[0], &data, 1);
202 ctx.expectError(GL_INVALID_VALUE);
203 ctx.endSection();
204
205 ctx.beginSection("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.");
206 ctx.glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0);
207 ctx.expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
208 ctx.endSection();
209
210 ctx.beginSection("GL_INVALID_VALUE is generated if count or length is negative.");
211 ctx.glShaderBinary(2, &shaderPair[0], binaryFormats[0], 0, -1);
212 ctx.expectError(GL_INVALID_VALUE);
213 ctx.glShaderBinary(-1, &shaderPair[0], binaryFormats[0], 0, 0);
214 ctx.expectError(GL_INVALID_VALUE);
215 ctx.endSection();
216
217 ctx.beginSection("GL_INVALID_VALUE is generated if shaders contains anything other than shader or program objects.");
218 ctx.glShaderBinary(2, &nonProgram[0], binaryFormats[0], 0, 0);
219 ctx.expectError(GL_INVALID_VALUE);
220 ctx.endSection();
221
222 ctx.beginSection("GL_INVALID_OPERATION is generated if shaders refers to a program object.");
223 ctx.glShaderBinary(2, &shaderProgram[0], binaryFormats[0], 0, 0);
224 ctx.expectError(GL_INVALID_OPERATION);
225 ctx.endSection();
226 }
227
228 ctx.glDeleteShader(shaders[0]);
229 ctx.glDeleteShader(shaders[1]);
230 }
231
attach_shader(NegativeTestContext & ctx)232 void attach_shader (NegativeTestContext& ctx)
233 {
234 GLuint shader1 = ctx.glCreateShader(GL_VERTEX_SHADER);
235 GLuint shader2 = ctx.glCreateShader(GL_VERTEX_SHADER);
236 GLuint program = ctx.glCreateProgram();
237
238 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER);
239 const GLuint notAProgram = ctx.glCreateProgram();
240
241 ctx.glDeleteShader(notAShader);
242 ctx.glDeleteProgram(notAProgram);
243
244 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
245 ctx.glAttachShader(shader1, shader1);
246 ctx.expectError(GL_INVALID_OPERATION);
247 ctx.endSection();
248
249 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
250 ctx.glAttachShader(program, program);
251 ctx.expectError(GL_INVALID_OPERATION);
252 ctx.glAttachShader(shader1, program);
253 ctx.expectError(GL_INVALID_OPERATION);
254 ctx.endSection();
255
256 ctx.beginSection("GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
257 ctx.glAttachShader(program, notAShader);
258 ctx.expectError(GL_INVALID_VALUE);
259 ctx.glAttachShader(notAProgram, shader1);
260 ctx.expectError(GL_INVALID_VALUE);
261 ctx.glAttachShader(notAProgram, notAShader);
262 ctx.expectError(GL_INVALID_VALUE);
263 ctx.endSection();
264
265 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is already attached to program.");
266 ctx.glAttachShader(program, shader1);
267 ctx.expectError(GL_NO_ERROR);
268 ctx.glAttachShader(program, shader1);
269 ctx.expectError(GL_INVALID_OPERATION);
270 ctx.endSection();
271
272 ctx.beginSection("GL_INVALID_OPERATION is generated if a shader of the same type as shader is already attached to program.");
273 ctx.glAttachShader(program, shader2);
274 ctx.expectError(GL_INVALID_OPERATION);
275 ctx.endSection();
276
277 ctx.glDeleteProgram(program);
278 ctx.glDeleteShader(shader1);
279 ctx.glDeleteShader(shader2);
280 }
281
detach_shader(NegativeTestContext & ctx)282 void detach_shader (NegativeTestContext& ctx)
283 {
284 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
285 GLuint program = ctx.glCreateProgram();
286
287 const GLuint notAShader = ctx.glCreateShader(GL_VERTEX_SHADER);
288 const GLuint notAProgram = ctx.glCreateProgram();
289
290 ctx.glDeleteShader(notAShader);
291 ctx.glDeleteProgram(notAProgram);
292
293 ctx.beginSection("GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
294 ctx.glDetachShader(notAProgram, shader);
295 ctx.expectError(GL_INVALID_VALUE);
296 ctx.glDetachShader(program, notAShader);
297 ctx.expectError(GL_INVALID_VALUE);
298 ctx.glDetachShader(notAProgram, notAShader);
299 ctx.expectError(GL_INVALID_VALUE);
300 ctx.endSection();
301
302 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
303 ctx.glDetachShader(shader, shader);
304 ctx.expectError(GL_INVALID_OPERATION);
305 ctx.endSection();
306
307 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not a shader object.");
308 ctx.glDetachShader(program, program);
309 ctx.expectError(GL_INVALID_OPERATION);
310 ctx.glDetachShader(shader, program);
311 ctx.expectError(GL_INVALID_OPERATION);
312 ctx.endSection();
313
314 ctx.beginSection("GL_INVALID_OPERATION is generated if shader is not attached to program.");
315 ctx.glDetachShader(program, shader);
316 ctx.expectError(GL_INVALID_OPERATION);
317 ctx.endSection();
318
319 ctx.glDeleteProgram(program);
320 ctx.glDeleteShader(shader);
321 }
322
link_program(NegativeTestContext & ctx)323 void link_program (NegativeTestContext& ctx)
324 {
325 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
326
327 const GLuint notAProgram = ctx.glCreateProgram();
328 ctx.glDeleteProgram(notAProgram);
329
330 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
331 ctx.glLinkProgram(notAProgram);
332 ctx.expectError(GL_INVALID_VALUE);
333 ctx.endSection();
334
335 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
336 ctx.glLinkProgram(shader);
337 ctx.expectError(GL_INVALID_OPERATION);
338 ctx.endSection();
339
340 ctx.glDeleteShader(shader);
341
342 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the currently active program object and transform feedback mode is active.");
343 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
344 deUint32 buf = 0x1234;
345 deUint32 tfID = 0x1234;
346 const char* tfVarying = "gl_Position";
347
348 ctx.glGenTransformFeedbacks (1, &tfID);
349 ctx.glGenBuffers (1, &buf);
350
351 ctx.glUseProgram (program.getProgram());
352 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
353 ctx.glLinkProgram (program.getProgram());
354 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
355 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
356 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
357 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
358 ctx.glBeginTransformFeedback (GL_TRIANGLES);
359 ctx.expectError (GL_NO_ERROR);
360
361 ctx.glLinkProgram (program.getProgram());
362 ctx.expectError (GL_INVALID_OPERATION);
363
364 ctx.glEndTransformFeedback ();
365 ctx.glDeleteTransformFeedbacks (1, &tfID);
366 ctx.glDeleteBuffers (1, &buf);
367 ctx.expectError (GL_NO_ERROR);
368 ctx.endSection();
369 }
370
use_program(NegativeTestContext & ctx)371 void use_program (NegativeTestContext& ctx)
372 {
373 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
374
375 const GLuint notAProgram = ctx.glCreateProgram();
376 ctx.glDeleteProgram(notAProgram);
377
378 ctx.beginSection("GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
379 ctx.glUseProgram(notAProgram);
380 ctx.expectError(GL_INVALID_VALUE);
381 ctx.endSection();
382
383 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
384 ctx.glUseProgram(shader);
385 ctx.expectError(GL_INVALID_OPERATION);
386 ctx.endSection();
387
388 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback mode is active and not paused.");
389 glu::ShaderProgram program1(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
390 glu::ShaderProgram program2(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
391 deUint32 buf = 0x1234;
392 deUint32 tfID = 0x1234;
393 const char* tfVarying = "gl_Position";
394
395 ctx.glGenTransformFeedbacks (1, &tfID);
396 ctx.glGenBuffers (1, &buf);
397
398 ctx.glUseProgram (program1.getProgram());
399 ctx.glTransformFeedbackVaryings (program1.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
400 ctx.glLinkProgram (program1.getProgram());
401 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
402 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
403 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
404 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
405 ctx.glBeginTransformFeedback (GL_TRIANGLES);
406 ctx.expectError (GL_NO_ERROR);
407
408 ctx.glUseProgram (program2.getProgram());
409 ctx.expectError (GL_INVALID_OPERATION);
410
411 ctx.glPauseTransformFeedback ();
412 ctx.glUseProgram (program2.getProgram());
413 ctx.expectError (GL_NO_ERROR);
414
415 ctx.glEndTransformFeedback ();
416 ctx.glDeleteTransformFeedbacks (1, &tfID);
417 ctx.glDeleteBuffers (1, &buf);
418 ctx.expectError (GL_NO_ERROR);
419 ctx.endSection();
420
421 ctx.glUseProgram(0);
422 ctx.glDeleteShader(shader);
423 }
424
delete_program(NegativeTestContext & ctx)425 void delete_program (NegativeTestContext& ctx)
426 {
427 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
428
429 const GLuint notAProgram = ctx.glCreateProgram();
430 ctx.glDeleteProgram(notAProgram);
431
432 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
433 ctx.glDeleteProgram(notAProgram);
434 ctx.expectError(GL_INVALID_VALUE);
435 ctx.endSection();
436
437 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not zero and is the name of a shader object.");
438 ctx.glDeleteProgram(shader);
439 ctx.expectError(GL_INVALID_OPERATION);
440 ctx.endSection();
441
442 ctx.glDeleteShader(shader);
443 }
444
validate_program(NegativeTestContext & ctx)445 void validate_program (NegativeTestContext& ctx)
446 {
447 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
448
449 const GLuint notAProgram = ctx.glCreateProgram();
450 ctx.glDeleteProgram(notAProgram);
451
452 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
453 ctx.glValidateProgram(notAProgram);
454 ctx.expectError(GL_INVALID_VALUE);
455 ctx.endSection();
456
457 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
458 ctx.glValidateProgram(shader);
459 ctx.expectError(GL_INVALID_OPERATION);
460 ctx.endSection();
461
462 ctx.glDeleteShader(shader);
463 }
464
get_program_binary(NegativeTestContext & ctx)465 void get_program_binary (NegativeTestContext& ctx)
466 {
467 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
468 glu::ShaderProgram programInvalid (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
469 GLenum binaryFormat = -1;
470 GLsizei binaryLength = -1;
471 GLint binaryPtr = -1;
472 GLint bufSize = -1;
473 GLint linkStatus = -1;
474
475 ctx.beginSection("GL_INVALID_OPERATION is generated if bufSize is less than the size of GL_PROGRAM_BINARY_LENGTH for program.");
476 ctx.glGetProgramiv (program.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
477 ctx.expectError (GL_NO_ERROR);
478 ctx.glGetProgramiv (program.getProgram(), GL_LINK_STATUS, &linkStatus);
479 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
480 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
481 ctx.expectError (GL_NO_ERROR);
482
483 ctx.glGetProgramBinary (program.getProgram(), 0, &binaryLength, &binaryFormat, &binaryPtr);
484 ctx.expectError (GL_INVALID_OPERATION);
485 if (bufSize > 0)
486 {
487 ctx.glGetProgramBinary (program.getProgram(), bufSize-1, &binaryLength, &binaryFormat, &binaryPtr);
488 ctx.expectError (GL_INVALID_OPERATION);
489 }
490 ctx.endSection();
491
492 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_LINK_STATUS for the program object is false.");
493 ctx.glGetProgramiv (programInvalid.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
494 ctx.expectError (GL_NO_ERROR);
495 ctx.glGetProgramiv (programInvalid.getProgram(), GL_LINK_STATUS, &linkStatus);
496 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
497 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
498 ctx.expectError (GL_NO_ERROR);
499
500 ctx.glGetProgramBinary (programInvalid.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryPtr);
501 ctx.expectError (GL_INVALID_OPERATION);
502 ctx.endSection();
503 }
504
program_binary(NegativeTestContext & ctx)505 void program_binary (NegativeTestContext& ctx)
506 {
507 glu::ShaderProgram srcProgram (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
508 GLuint dstProgram = ctx.glCreateProgram();
509 GLuint dummyShader = ctx.glCreateShader(GL_VERTEX_SHADER);
510 GLenum binaryFormat = -1;
511 GLsizei binaryLength = -1;
512 std::vector<deUint8> binaryBuf;
513 GLint bufSize = -1;
514 GLint linkStatus = -1;
515
516 ctx.glGetProgramiv (srcProgram.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
517 ctx.glGetProgramiv (srcProgram.getProgram(), GL_LINK_STATUS, &linkStatus);
518 ctx.getLog() << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
519 ctx.getLog() << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
520
521 TCU_CHECK(bufSize >= 0);
522 if (bufSize > 0)
523 {
524 binaryBuf.resize(bufSize);
525 ctx.glGetProgramBinary (srcProgram.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryBuf[0]);
526 ctx.expectError (GL_NO_ERROR);
527
528 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not the name of an existing program object.");
529 ctx.glProgramBinary (dummyShader, binaryFormat, &binaryBuf[0], binaryLength);
530 ctx.expectError (GL_INVALID_OPERATION);
531 ctx.endSection();
532
533 ctx.beginSection("GL_INVALID_ENUM is generated if binaryFormat is not a value recognized by the implementation.");
534 ctx.glProgramBinary (dstProgram, -1, &binaryBuf[0], binaryLength);
535 ctx.expectError (GL_INVALID_ENUM);
536 ctx.endSection();
537 }
538
539 ctx.glDeleteShader(dummyShader);
540 ctx.glDeleteProgram(dstProgram);
541 }
542
program_parameteri(NegativeTestContext & ctx)543 void program_parameteri (NegativeTestContext& ctx)
544 {
545 GLuint program = ctx.glCreateProgram();
546 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
547
548 const GLuint notAProgram = ctx.glCreateProgram();
549 ctx.glDeleteProgram(notAProgram);
550
551 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of an existing program object.");
552 ctx.glProgramParameteri(notAProgram, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
553 ctx.expectError(GL_INVALID_VALUE);
554 ctx.endSection();
555
556 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
557 ctx.glProgramParameteri(shader, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
558 ctx.expectError(GL_INVALID_OPERATION);
559 ctx.endSection();
560
561 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT or PROGRAM_SEPARABLE.");
562 ctx.glProgramParameteri(program, -1, GL_TRUE);
563 ctx.expectError(GL_INVALID_ENUM);
564 ctx.endSection();
565
566 ctx.beginSection("GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE.");
567 ctx.glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
568 ctx.expectError(GL_INVALID_VALUE);
569 ctx.endSection();
570
571 ctx.glDeleteProgram(program);
572 ctx.glDeleteShader(shader);
573 }
574
gen_samplers(NegativeTestContext & ctx)575 void gen_samplers (NegativeTestContext& ctx)
576 {
577 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
578 GLuint sampler = 0;
579 ctx.glGenSamplers (-1, &sampler);
580 ctx.expectError (GL_INVALID_VALUE);
581 ctx.endSection();
582 }
583
bind_sampler(NegativeTestContext & ctx)584 void bind_sampler (NegativeTestContext& ctx)
585 {
586 int maxTexImageUnits = 0x1234;
587 GLuint sampler = 0;
588 ctx.glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits);
589 ctx.glGenSamplers (1, &sampler);
590
591 ctx.beginSection("GL_INVALID_VALUE is generated if unit is greater than or equal to the value of GL_MAX_COMBIED_TEXTURE_IMAGE_UNITS.");
592 ctx.glBindSampler (maxTexImageUnits, sampler);
593 ctx.expectError (GL_INVALID_VALUE);
594 ctx.endSection();
595
596 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not zero or a name previously returned from a call to ctx.glGenSamplers.");
597 ctx.glBindSampler (1, -1);
598 ctx.expectError (GL_INVALID_OPERATION);
599 ctx.endSection();
600
601 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler has been deleted by a call to ctx.glDeleteSamplers.");
602 ctx.glDeleteSamplers(1, &sampler);
603 ctx.glBindSampler (1, sampler);
604 ctx.expectError (GL_INVALID_OPERATION);
605 ctx.endSection();
606 }
607
delete_samplers(NegativeTestContext & ctx)608 void delete_samplers (NegativeTestContext& ctx)
609 {
610 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
611 ctx.glDeleteSamplers(-1, 0);
612 ctx.expectError (GL_INVALID_VALUE);
613 ctx.endSection();
614 }
615
get_sampler_parameteriv(NegativeTestContext & ctx)616 void get_sampler_parameteriv (NegativeTestContext& ctx)
617 {
618 int params = 0x1234;
619 GLuint sampler = 0;
620 ctx.glGenSamplers (1, &sampler);
621
622 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
623 ctx.glGetSamplerParameteriv (-1, GL_TEXTURE_MAG_FILTER, ¶ms);
624 ctx.expectError (GL_INVALID_OPERATION);
625 ctx.endSection();
626
627 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
628 ctx.glGetSamplerParameteriv (sampler, -1, ¶ms);
629 ctx.expectError (GL_INVALID_ENUM);
630 ctx.endSection();
631
632 ctx.glDeleteSamplers(1, &sampler);
633 }
634
get_sampler_parameterfv(NegativeTestContext & ctx)635 void get_sampler_parameterfv (NegativeTestContext& ctx)
636 {
637 float params = 0.0f;
638 GLuint sampler = 0;
639 ctx.glGenSamplers (1, &sampler);
640
641 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
642 ctx.glGetSamplerParameterfv (-1, GL_TEXTURE_MAG_FILTER, ¶ms);
643 ctx.expectError (GL_INVALID_OPERATION);
644 ctx.endSection();
645
646 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
647 ctx.glGetSamplerParameterfv (sampler, -1, ¶ms);
648 ctx.expectError (GL_INVALID_ENUM);
649 ctx.endSection();
650
651 ctx.glDeleteSamplers(1, &sampler);
652 }
653
get_sampler_parameterIiv(NegativeTestContext & ctx)654 void get_sampler_parameterIiv (NegativeTestContext& ctx)
655 {
656 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
657 throw tcu::NotSupportedError("glGetSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
658
659 GLuint sampler = 0x1234;
660 GLint borderColor = 0x1234;
661
662 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
663 ctx.glGetSamplerParameterIiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor);
664 ctx.expectError(GL_INVALID_OPERATION);
665 ctx.endSection();
666
667 ctx.glGenSamplers(1, &sampler);
668
669 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
670 ctx.glGetSamplerParameterIiv(sampler, -1, &borderColor);
671 ctx.expectError(GL_INVALID_ENUM);
672 ctx.endSection();
673
674 ctx.glDeleteSamplers(1, &sampler);
675 }
676
get_sampler_parameterIuiv(NegativeTestContext & ctx)677 void get_sampler_parameterIuiv (NegativeTestContext& ctx)
678 {
679 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
680 throw tcu::NotSupportedError("glGetSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
681
682 GLuint sampler = 0x1234;
683 GLuint borderColor = 0x1234;
684
685 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
686 ctx.glGetSamplerParameterIuiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor);
687 ctx.expectError(GL_INVALID_OPERATION);
688 ctx.endSection();
689
690 ctx.glGenSamplers(1, &sampler);
691
692 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
693 ctx.glGetSamplerParameterIuiv(sampler, -1, &borderColor);
694 ctx.expectError(GL_INVALID_ENUM);
695 ctx.endSection();
696
697 ctx.glDeleteSamplers(1, &sampler);
698 }
699
sampler_parameteri(NegativeTestContext & ctx)700 void sampler_parameteri (NegativeTestContext& ctx)
701 {
702 GLuint sampler = 0;
703
704 ctx.glGenSamplers(1, &sampler);
705
706 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
707 ctx.glSamplerParameteri(-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
708 ctx.expectError(GL_INVALID_OPERATION);
709 ctx.endSection();
710
711 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
712 ctx.glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, -1);
713 ctx.expectError(GL_INVALID_ENUM);
714 ctx.endSection();
715
716 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
717 {
718 ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameteri is called for a non-scalar parameter.");
719 ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0);
720 ctx.expectError(GL_INVALID_ENUM);
721 ctx.endSection();
722 }
723
724 ctx.glDeleteSamplers(1, &sampler);
725 }
726
sampler_parameteriv(NegativeTestContext & ctx)727 void sampler_parameteriv (NegativeTestContext& ctx)
728 {
729 int params = 0x1234;
730 GLuint sampler = 0;
731 ctx.glGenSamplers (1, &sampler);
732
733 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
734 params = GL_CLAMP_TO_EDGE;
735 ctx.glSamplerParameteriv (-1, GL_TEXTURE_WRAP_S, ¶ms);
736 ctx.expectError (GL_INVALID_OPERATION);
737 ctx.endSection();
738
739 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
740 params = -1;
741 ctx.glSamplerParameteriv (sampler, GL_TEXTURE_WRAP_S, ¶ms);
742 ctx.expectError (GL_INVALID_ENUM);
743 ctx.endSection();
744
745 ctx.glDeleteSamplers(1, &sampler);
746 }
747
sampler_parameterf(NegativeTestContext & ctx)748 void sampler_parameterf (NegativeTestContext& ctx)
749 {
750 GLuint sampler = 0;
751
752 ctx.glGenSamplers(1, &sampler);
753
754 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
755 ctx.glSamplerParameterf(-1, GL_TEXTURE_MIN_LOD, -1000.0f);
756 ctx.expectError(GL_INVALID_OPERATION);
757 ctx.endSection();
758
759 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
760 ctx.glSamplerParameterf(sampler, GL_TEXTURE_WRAP_S, -1.0f);
761 ctx.expectError(GL_INVALID_ENUM);
762 ctx.endSection();
763
764 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
765 {
766 ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameterf is called for a non-scalar parameter.");
767 ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0);
768 ctx.expectError(GL_INVALID_ENUM);
769 ctx.endSection();
770 }
771
772 ctx.glDeleteSamplers(1, &sampler);
773 }
774
sampler_parameterfv(NegativeTestContext & ctx)775 void sampler_parameterfv (NegativeTestContext& ctx)
776 {
777 float params;
778 GLuint sampler = 0;
779 ctx.glGenSamplers (1, &sampler);
780
781 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
782 params = -1000.0f;
783 ctx.glSamplerParameterfv (-1, GL_TEXTURE_WRAP_S, ¶ms);
784 ctx.expectError (GL_INVALID_OPERATION);
785 ctx.endSection();
786
787 ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
788 params = -1.0f;
789 ctx.glSamplerParameterfv (sampler, GL_TEXTURE_WRAP_S, ¶ms);
790 ctx.expectError (GL_INVALID_ENUM);
791 ctx.endSection();
792
793 ctx.glDeleteSamplers(1, &sampler);
794 }
795
sampler_parameterIiv(NegativeTestContext & ctx)796 void sampler_parameterIiv (NegativeTestContext& ctx)
797 {
798 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
799 throw tcu::NotSupportedError("glSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
800
801 GLuint sampler;
802 GLint color[] = {0, 0, 0, 0};
803
804 ctx.glGenSamplers(1, &sampler);
805
806 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
807 ctx.glSamplerParameterIiv(-1, GL_TEXTURE_BORDER_COLOR, color);
808 ctx.expectError(GL_INVALID_OPERATION);
809 ctx.endSection();
810
811 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name.");
812 ctx.glSamplerParameterIiv(sampler, -1, color);
813 ctx.expectError(GL_INVALID_ENUM);
814 ctx.endSection();
815 }
816
sampler_parameterIuiv(NegativeTestContext & ctx)817 void sampler_parameterIuiv (NegativeTestContext& ctx)
818 {
819 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
820 throw tcu::NotSupportedError("glSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
821
822 GLuint sampler;
823 GLuint color[] = {0, 0, 0, 0};
824
825 ctx.glGenSamplers(1, &sampler);
826
827 ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
828 ctx.glSamplerParameterIuiv(-1, GL_TEXTURE_BORDER_COLOR, color);
829 ctx.expectError(GL_INVALID_OPERATION);
830 ctx.endSection();
831
832 ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name.");
833 ctx.glSamplerParameterIuiv(sampler, -1, color);
834 ctx.expectError(GL_INVALID_ENUM);
835 ctx.endSection();
836 }
837
838 // Shader data commands
839
get_attrib_location(NegativeTestContext & ctx)840 void get_attrib_location (NegativeTestContext& ctx)
841 {
842 GLuint programEmpty = ctx.glCreateProgram();
843 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
844
845 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
846
847 const GLuint notAProgram = ctx.glCreateProgram();
848 ctx.glDeleteProgram(notAProgram);
849
850 ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
851 ctx.glBindAttribLocation (programEmpty, 0, "test");
852 ctx.glGetAttribLocation (programEmpty, "test");
853 ctx.expectError (GL_INVALID_OPERATION);
854 ctx.endSection();
855
856 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a program or shader object.");
857 ctx.glUseProgram (program.getProgram());
858 ctx.glBindAttribLocation (program.getProgram(), 0, "test");
859 ctx.expectError (GL_NO_ERROR);
860 ctx.glGetAttribLocation (program.getProgram(), "test");
861 ctx.expectError (GL_NO_ERROR);
862 ctx.glGetAttribLocation (notAProgram, "test");
863 ctx.expectError (GL_INVALID_VALUE);
864 ctx.endSection();
865
866 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
867 ctx.glGetAttribLocation (shader, "test");
868 ctx.expectError (GL_INVALID_OPERATION);
869 ctx.endSection();
870
871 ctx.glUseProgram (0);
872 ctx.glDeleteShader (shader);
873 ctx.glDeleteProgram (programEmpty);
874 }
875
get_uniform_location(NegativeTestContext & ctx)876 void get_uniform_location (NegativeTestContext& ctx)
877 {
878 GLuint programEmpty = ctx.glCreateProgram();
879 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
880
881 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
882
883 const GLuint notAProgram = ctx.glCreateProgram();
884 ctx.glDeleteProgram(notAProgram);
885
886 ctx.beginSection("GL_INVALID_OPERATION is generated if program has not been successfully linked.");
887 ctx.glGetUniformLocation(programEmpty, "test");
888 ctx.expectError(GL_INVALID_OPERATION);
889 ctx.endSection();
890
891 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
892 ctx.glUseProgram(program.getProgram());
893 ctx.glGetUniformLocation(notAProgram, "test");
894 ctx.expectError(GL_INVALID_VALUE);
895 ctx.endSection();
896
897 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
898 ctx.glGetAttribLocation(shader, "test");
899 ctx.expectError(GL_INVALID_OPERATION);
900 ctx.endSection();
901
902 ctx.glUseProgram(0);
903 ctx.glDeleteProgram(programEmpty);
904 ctx.glDeleteShader(shader);
905 }
906
bind_attrib_location(NegativeTestContext & ctx)907 void bind_attrib_location (NegativeTestContext& ctx)
908 {
909 GLuint program = ctx.glCreateProgram();
910 GLuint maxIndex = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
911 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
912
913 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
914 ctx.glBindAttribLocation(program, maxIndex, "test");
915 ctx.expectError(GL_INVALID_VALUE);
916 ctx.endSection();
917
918 ctx.beginSection("GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
919 ctx.glBindAttribLocation(program, maxIndex-1, "gl_test");
920 ctx.expectError(GL_INVALID_OPERATION);
921 ctx.endSection();
922
923 ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
924 ctx.glBindAttribLocation(-1, maxIndex-1, "test");
925 ctx.expectError(GL_INVALID_VALUE);
926 ctx.endSection();
927
928 ctx.beginSection("GL_INVALID_OPERATION is generated if program is not a program object.");
929 ctx.glBindAttribLocation(shader, maxIndex-1, "test");
930 ctx.expectError(GL_INVALID_OPERATION);
931 ctx.endSection();
932
933 ctx.glDeleteProgram(program);
934 ctx.glDeleteShader(shader);
935 }
936
uniform_block_binding(NegativeTestContext & ctx)937 void uniform_block_binding (NegativeTestContext& ctx)
938 {
939 GLint maxUniformBufferBindings = -1;
940 GLint numActiveUniforms = -1;
941 GLint numActiveBlocks = -1;
942 GLuint shader = -1;
943 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
944
945 shader = ctx.glCreateShader(GL_VERTEX_SHADER);
946 ctx.glUseProgram(program.getProgram());
947
948 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
949 ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
950 ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
951 ctx.getLog() << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings << TestLog::EndMessage;
952 ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << TestLog::EndMessage;
953 ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << TestLog::EndMessage;
954 ctx.expectError (GL_NO_ERROR);
955
956 ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program.");
957 ctx.glUniformBlockBinding(program.getProgram(), -1, 0);
958 ctx.expectError(GL_INVALID_VALUE);
959 ctx.glUniformBlockBinding(program.getProgram(), 5, 0);
960 ctx.expectError(GL_INVALID_VALUE);
961 ctx.endSection();
962
963 ctx.beginSection("GL_INVALID_VALUE is generated if uniformBlockBinding is greater than or equal to the value of GL_MAX_UNIFORM_BUFFER_BINDINGS.");
964 ctx.glUniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0);
965 ctx.expectError(GL_INVALID_VALUE);
966 ctx.endSection();
967
968 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object generated by the GL.");
969 ctx.glUniformBlockBinding(-1, 0, 0);
970 ctx.expectError(GL_INVALID_VALUE);
971 ctx.endSection();
972
973 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
974 ctx.glUniformBlockBinding(shader, 0, 0);
975 ctx.expectError(GL_INVALID_OPERATION);
976 ctx.endSection();
977
978 ctx.glDeleteShader(shader);
979 }
980
981 // ctx.glUniform*f
982
uniformf_invalid_program(NegativeTestContext & ctx)983 void uniformf_invalid_program (NegativeTestContext& ctx)
984 {
985 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
986 ctx.glUseProgram(0);
987 ctx.glUniform1f(-1, 0.0f);
988 ctx.expectError(GL_INVALID_OPERATION);
989 ctx.glUniform2f(-1, 0.0f, 0.0f);
990 ctx.expectError(GL_INVALID_OPERATION);
991 ctx.glUniform3f(-1, 0.0f, 0.0f, 0.0f);
992 ctx.expectError(GL_INVALID_OPERATION);
993 ctx.glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
994 ctx.expectError(GL_INVALID_OPERATION);
995 ctx.endSection();
996 }
997
uniformf_incompatible_type(NegativeTestContext & ctx)998 void uniformf_incompatible_type (NegativeTestContext& ctx)
999 {
1000 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1001
1002 ctx.glUseProgram(program.getProgram());
1003 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1004 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1005 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1006 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1007 ctx.expectError(GL_NO_ERROR);
1008
1009 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1010 {
1011 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1012 ctx.fail("Failed to retrieve uniform location");
1013 }
1014
1015 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1016 ctx.glUseProgram(program.getProgram());
1017 ctx.glUniform1f(vec4_v, 0.0f);
1018 ctx.expectError(GL_INVALID_OPERATION);
1019 ctx.glUniform2f(vec4_v, 0.0f, 0.0f);
1020 ctx.expectError(GL_INVALID_OPERATION);
1021 ctx.glUniform3f(vec4_v, 0.0f, 0.0f, 0.0f);
1022 ctx.expectError(GL_INVALID_OPERATION);
1023 ctx.glUniform4f(vec4_v, 0.0f, 0.0f, 0.0f, 0.0f);
1024 ctx.expectError(GL_NO_ERROR);
1025 ctx.endSection();
1026
1027 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}f is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
1028 ctx.glUseProgram(program.getProgram());
1029 ctx.glUniform4f(ivec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
1030 ctx.expectError(GL_INVALID_OPERATION);
1031 ctx.glUniform4f(uvec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
1032 ctx.expectError(GL_INVALID_OPERATION);
1033 ctx.endSection();
1034
1035 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv.");
1036 ctx.glUseProgram(program.getProgram());
1037 ctx.glUniform1f(sampler_f, 0.0f);
1038 ctx.expectError(GL_INVALID_OPERATION);
1039 ctx.endSection();
1040
1041 ctx.glUseProgram(0);
1042 }
1043
uniformf_invalid_location(NegativeTestContext & ctx)1044 void uniformf_invalid_location (NegativeTestContext& ctx)
1045 {
1046 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1047
1048 ctx.glUseProgram(program.getProgram());
1049 ctx.expectError(GL_NO_ERROR);
1050
1051 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1052 ctx.glUseProgram(program.getProgram());
1053 ctx.glUniform1f(-2, 0.0f);
1054 ctx.expectError(GL_INVALID_OPERATION);
1055 ctx.glUniform2f(-2, 0.0f, 0.0f);
1056 ctx.expectError(GL_INVALID_OPERATION);
1057 ctx.glUniform3f(-2, 0.0f, 0.0f, 0.0f);
1058 ctx.expectError(GL_INVALID_OPERATION);
1059 ctx.glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
1060 ctx.expectError(GL_INVALID_OPERATION);
1061
1062 ctx.glUseProgram(program.getProgram());
1063 ctx.glUniform1f(-1, 0.0f);
1064 ctx.expectError(GL_NO_ERROR);
1065 ctx.glUniform2f(-1, 0.0f, 0.0f);
1066 ctx.expectError(GL_NO_ERROR);
1067 ctx.glUniform3f(-1, 0.0f, 0.0f, 0.0f);
1068 ctx.expectError(GL_NO_ERROR);
1069 ctx.glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
1070 ctx.expectError(GL_NO_ERROR);
1071 ctx.endSection();
1072
1073 ctx.glUseProgram(0);
1074 }
1075
1076 // ctx.glUniform*fv
1077
uniformfv_invalid_program(NegativeTestContext & ctx)1078 void uniformfv_invalid_program (NegativeTestContext& ctx)
1079 {
1080 std::vector<GLfloat> data(4);
1081
1082 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1083 ctx.glUseProgram(0);
1084 ctx.glUniform1fv(-1, 1, &data[0]);
1085 ctx.expectError(GL_INVALID_OPERATION);
1086 ctx.glUniform2fv(-1, 1, &data[0]);
1087 ctx.expectError(GL_INVALID_OPERATION);
1088 ctx.glUniform3fv(-1, 1, &data[0]);
1089 ctx.expectError(GL_INVALID_OPERATION);
1090 ctx.glUniform4fv(-1, 1, &data[0]);
1091 ctx.expectError(GL_INVALID_OPERATION);
1092 ctx.endSection();
1093 }
1094
uniformfv_incompatible_type(NegativeTestContext & ctx)1095 void uniformfv_incompatible_type (NegativeTestContext& ctx)
1096 {
1097 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1098
1099 ctx.glUseProgram(program.getProgram());
1100 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1101 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1102 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1103 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1104 ctx.expectError(GL_NO_ERROR);
1105
1106 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1107 {
1108 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1109 ctx.fail("Failed to retrieve uniform location");
1110 }
1111
1112 std::vector<GLfloat> data(4);
1113
1114 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1115 ctx.glUseProgram(program.getProgram());
1116 ctx.glUniform1fv(vec4_v, 1, &data[0]);
1117 ctx.expectError(GL_INVALID_OPERATION);
1118 ctx.glUniform2fv(vec4_v, 1, &data[0]);
1119 ctx.expectError(GL_INVALID_OPERATION);
1120 ctx.glUniform3fv(vec4_v, 1, &data[0]);
1121 ctx.expectError(GL_INVALID_OPERATION);
1122 ctx.glUniform4fv(vec4_v, 1, &data[0]);
1123 ctx.expectError(GL_NO_ERROR);
1124 ctx.endSection();
1125
1126 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}fv is used to load a uniform variable of type int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
1127 ctx.glUseProgram(program.getProgram());
1128 ctx.glUniform4fv(ivec4_f, 1, &data[0]);
1129 ctx.expectError(GL_INVALID_OPERATION);
1130 ctx.glUniform4fv(uvec4_f, 1, &data[0]);
1131 ctx.expectError(GL_INVALID_OPERATION);
1132 ctx.endSection();
1133
1134 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv.");
1135 ctx.glUseProgram(program.getProgram());
1136 ctx.glUniform1fv(sampler_f, 1, &data[0]);
1137 ctx.expectError(GL_INVALID_OPERATION);
1138 ctx.endSection();
1139
1140 ctx.glUseProgram(0);
1141 }
1142
uniformfv_invalid_location(NegativeTestContext & ctx)1143 void uniformfv_invalid_location (NegativeTestContext& ctx)
1144 {
1145 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1146
1147 ctx.glUseProgram(program.getProgram());
1148 ctx.expectError(GL_NO_ERROR);
1149
1150 std::vector<GLfloat> data(4);
1151
1152 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1153 ctx.glUseProgram(program.getProgram());
1154 ctx.glUniform1fv(-2, 1, &data[0]);
1155 ctx.expectError(GL_INVALID_OPERATION);
1156 ctx.glUniform2fv(-2, 1, &data[0]);
1157 ctx.expectError(GL_INVALID_OPERATION);
1158 ctx.glUniform3fv(-2, 1, &data[0]);
1159 ctx.expectError(GL_INVALID_OPERATION);
1160 ctx.glUniform4fv(-2, 1, &data[0]);
1161 ctx.expectError(GL_INVALID_OPERATION);
1162
1163 ctx.glUseProgram(program.getProgram());
1164 ctx.glUniform1fv(-1, 1, &data[0]);
1165 ctx.expectError(GL_NO_ERROR);
1166 ctx.glUniform2fv(-1, 1, &data[0]);
1167 ctx.expectError(GL_NO_ERROR);
1168 ctx.glUniform3fv(-1, 1, &data[0]);
1169 ctx.expectError(GL_NO_ERROR);
1170 ctx.glUniform4fv(-1, 1, &data[0]);
1171 ctx.expectError(GL_NO_ERROR);
1172 ctx.endSection();
1173
1174 ctx.glUseProgram(0);
1175 }
1176
uniformfv_invalid_count(NegativeTestContext & ctx)1177 void uniformfv_invalid_count (NegativeTestContext& ctx)
1178 {
1179 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1180
1181 ctx.glUseProgram (program.getProgram());
1182 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1183 ctx.expectError(GL_NO_ERROR);
1184
1185 if (vec4_v == -1)
1186 {
1187 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1188 ctx.fail("Failed to retrieve uniform location");
1189 }
1190
1191 std::vector<GLfloat> data(8);
1192
1193 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1194 ctx.glUseProgram(program.getProgram());
1195 ctx.glUniform1fv(vec4_v, 2, &data[0]);
1196 ctx.expectError(GL_INVALID_OPERATION);
1197 ctx.glUniform2fv(vec4_v, 2, &data[0]);
1198 ctx.expectError(GL_INVALID_OPERATION);
1199 ctx.glUniform3fv(vec4_v, 2, &data[0]);
1200 ctx.expectError(GL_INVALID_OPERATION);
1201 ctx.glUniform4fv(vec4_v, 2, &data[0]);
1202 ctx.expectError(GL_INVALID_OPERATION);
1203 ctx.endSection();
1204
1205 ctx.glUseProgram(0);
1206 }
1207
1208 // ctx.glUniform*i
1209
uniformi_invalid_program(NegativeTestContext & ctx)1210 void uniformi_invalid_program (NegativeTestContext& ctx)
1211 {
1212 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1213 ctx.glUseProgram(0);
1214 ctx.glUniform1i(-1, 0);
1215 ctx.expectError(GL_INVALID_OPERATION);
1216 ctx.glUniform2i(-1, 0, 0);
1217 ctx.expectError(GL_INVALID_OPERATION);
1218 ctx.glUniform3i(-1, 0, 0, 0);
1219 ctx.expectError(GL_INVALID_OPERATION);
1220 ctx.glUniform4i(-1, 0, 0, 0, 0);
1221 ctx.expectError(GL_INVALID_OPERATION);
1222 ctx.endSection();
1223 }
1224
uniformi_incompatible_type(NegativeTestContext & ctx)1225 void uniformi_incompatible_type (NegativeTestContext& ctx)
1226 {
1227 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1228
1229 ctx.glUseProgram(program.getProgram());
1230 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1231 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1232 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1233 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1234 ctx.expectError(GL_NO_ERROR);
1235
1236 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1237 {
1238 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1239 ctx.fail("Failed to retrieve uniform location");
1240 }
1241
1242 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1243 ctx.glUseProgram(program.getProgram());
1244 ctx.glUniform1i(ivec4_f, 0);
1245 ctx.expectError(GL_INVALID_OPERATION);
1246 ctx.glUniform2i(ivec4_f, 0, 0);
1247 ctx.expectError(GL_INVALID_OPERATION);
1248 ctx.glUniform3i(ivec4_f, 0, 0, 0);
1249 ctx.expectError(GL_INVALID_OPERATION);
1250 ctx.glUniform4i(ivec4_f, 0, 0, 0, 0);
1251 ctx.expectError(GL_NO_ERROR);
1252 ctx.endSection();
1253
1254 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type unsigned int, uvec2, uvec3, uvec4, or an array of these.");
1255 ctx.glUseProgram(program.getProgram());
1256 ctx.glUniform1i(uvec4_f, 0);
1257 ctx.expectError(GL_INVALID_OPERATION);
1258 ctx.glUniform2i(uvec4_f, 0, 0);
1259 ctx.expectError(GL_INVALID_OPERATION);
1260 ctx.glUniform3i(uvec4_f, 0, 0, 0);
1261 ctx.expectError(GL_INVALID_OPERATION);
1262 ctx.glUniform4i(uvec4_f, 0, 0, 0, 0);
1263 ctx.expectError(GL_INVALID_OPERATION);
1264 ctx.endSection();
1265
1266 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1267 ctx.glUseProgram(program.getProgram());
1268 ctx.glUniform1i(vec4_v, 0);
1269 ctx.expectError(GL_INVALID_OPERATION);
1270 ctx.glUniform2i(vec4_v, 0, 0);
1271 ctx.expectError(GL_INVALID_OPERATION);
1272 ctx.glUniform3i(vec4_v, 0, 0, 0);
1273 ctx.expectError(GL_INVALID_OPERATION);
1274 ctx.glUniform4i(vec4_v, 0, 0, 0, 0);
1275 ctx.expectError(GL_INVALID_OPERATION);
1276 ctx.endSection();
1277
1278 ctx.glUseProgram(0);
1279 }
1280
uniformi_invalid_location(NegativeTestContext & ctx)1281 void uniformi_invalid_location (NegativeTestContext& ctx)
1282 {
1283 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1284
1285 ctx.glUseProgram(program.getProgram());
1286 ctx.expectError(GL_NO_ERROR);
1287
1288 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1289 ctx.glUseProgram(program.getProgram());
1290 ctx.glUniform1i(-2, 0);
1291 ctx.expectError(GL_INVALID_OPERATION);
1292 ctx.glUniform2i(-2, 0, 0);
1293 ctx.expectError(GL_INVALID_OPERATION);
1294 ctx.glUniform3i(-2, 0, 0, 0);
1295 ctx.expectError(GL_INVALID_OPERATION);
1296 ctx.glUniform4i(-2, 0, 0, 0, 0);
1297 ctx.expectError(GL_INVALID_OPERATION);
1298
1299 ctx.glUseProgram(program.getProgram());
1300 ctx.glUniform1i(-1, 0);
1301 ctx.expectError(GL_NO_ERROR);
1302 ctx.glUniform2i(-1, 0, 0);
1303 ctx.expectError(GL_NO_ERROR);
1304 ctx.glUniform3i(-1, 0, 0, 0);
1305 ctx.expectError(GL_NO_ERROR);
1306 ctx.glUniform4i(-1, 0, 0, 0, 0);
1307 ctx.expectError(GL_NO_ERROR);
1308 ctx.endSection();
1309
1310 ctx.glUseProgram(0);
1311 }
1312
1313 // ctx.glUniform*iv
1314
uniformiv_invalid_program(NegativeTestContext & ctx)1315 void uniformiv_invalid_program (NegativeTestContext& ctx)
1316 {
1317 std::vector<GLint> data(4);
1318
1319 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1320 ctx.glUseProgram(0);
1321 ctx.glUniform1iv(-1, 1, &data[0]);
1322 ctx.expectError(GL_INVALID_OPERATION);
1323 ctx.glUniform2iv(-1, 1, &data[0]);
1324 ctx.expectError(GL_INVALID_OPERATION);
1325 ctx.glUniform3iv(-1, 1, &data[0]);
1326 ctx.expectError(GL_INVALID_OPERATION);
1327 ctx.glUniform4iv(-1, 1, &data[0]);
1328 ctx.expectError(GL_INVALID_OPERATION);
1329 ctx.endSection();
1330 }
1331
uniformiv_incompatible_type(NegativeTestContext & ctx)1332 void uniformiv_incompatible_type (NegativeTestContext& ctx)
1333 {
1334 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1335
1336 ctx.glUseProgram(program.getProgram());
1337 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1338 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1339 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1340 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1341 ctx.expectError(GL_NO_ERROR);
1342
1343 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1344 {
1345 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1346 ctx.fail("Failed to retrieve uniform location");
1347 }
1348
1349 std::vector<GLint> data(4);
1350
1351 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1352 ctx.glUseProgram(program.getProgram());
1353 ctx.glUniform1iv(ivec4_f, 1, &data[0]);
1354 ctx.expectError(GL_INVALID_OPERATION);
1355 ctx.glUniform2iv(ivec4_f, 1, &data[0]);
1356 ctx.expectError(GL_INVALID_OPERATION);
1357 ctx.glUniform3iv(ivec4_f, 1, &data[0]);
1358 ctx.expectError(GL_INVALID_OPERATION);
1359 ctx.glUniform4iv(ivec4_f, 1, &data[0]);
1360 ctx.expectError(GL_NO_ERROR);
1361 ctx.endSection();
1362
1363 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}iv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1364 ctx.glUseProgram(program.getProgram());
1365 ctx.glUniform1iv(vec4_v, 1, &data[0]);
1366 ctx.expectError(GL_INVALID_OPERATION);
1367 ctx.glUniform2iv(vec4_v, 1, &data[0]);
1368 ctx.expectError(GL_INVALID_OPERATION);
1369 ctx.glUniform3iv(vec4_v, 1, &data[0]);
1370 ctx.expectError(GL_INVALID_OPERATION);
1371 ctx.glUniform4iv(vec4_v, 1, &data[0]);
1372 ctx.expectError(GL_INVALID_OPERATION);
1373 ctx.endSection();
1374
1375 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}iv is used to load a uniform variable of type unsigned int, uvec2, uvec3 or uvec4.");
1376 ctx.glUseProgram(program.getProgram());
1377 ctx.glUniform1iv(uvec4_f, 1, &data[0]);
1378 ctx.expectError(GL_INVALID_OPERATION);
1379 ctx.glUniform2iv(uvec4_f, 1, &data[0]);
1380 ctx.expectError(GL_INVALID_OPERATION);
1381 ctx.glUniform3iv(uvec4_f, 1, &data[0]);
1382 ctx.expectError(GL_INVALID_OPERATION);
1383 ctx.glUniform4iv(uvec4_f, 1, &data[0]);
1384 ctx.expectError(GL_INVALID_OPERATION);
1385 ctx.endSection();
1386
1387 ctx.glUseProgram(0);
1388 }
1389
uniformiv_invalid_location(NegativeTestContext & ctx)1390 void uniformiv_invalid_location (NegativeTestContext& ctx)
1391 {
1392 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1393
1394 ctx.glUseProgram(program.getProgram());
1395 ctx.expectError(GL_NO_ERROR);
1396
1397 std::vector<GLint> data(4);
1398
1399 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1400 ctx.glUseProgram(program.getProgram());
1401 ctx.glUniform1iv(-2, 1, &data[0]);
1402 ctx.expectError(GL_INVALID_OPERATION);
1403 ctx.glUniform2iv(-2, 1, &data[0]);
1404 ctx.expectError(GL_INVALID_OPERATION);
1405 ctx.glUniform3iv(-2, 1, &data[0]);
1406 ctx.expectError(GL_INVALID_OPERATION);
1407 ctx.glUniform4iv(-2, 1, &data[0]);
1408 ctx.expectError(GL_INVALID_OPERATION);
1409
1410 ctx.glUseProgram(program.getProgram());
1411 ctx.glUniform1iv(-1, 1, &data[0]);
1412 ctx.expectError(GL_NO_ERROR);
1413 ctx.glUniform2iv(-1, 1, &data[0]);
1414 ctx.expectError(GL_NO_ERROR);
1415 ctx.glUniform3iv(-1, 1, &data[0]);
1416 ctx.expectError(GL_NO_ERROR);
1417 ctx.glUniform4iv(-1, 1, &data[0]);
1418 ctx.expectError(GL_NO_ERROR);
1419 ctx.endSection();
1420
1421 ctx.glUseProgram(0);
1422 }
1423
uniformiv_invalid_count(NegativeTestContext & ctx)1424 void uniformiv_invalid_count (NegativeTestContext& ctx)
1425 {
1426 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1427
1428 ctx.glUseProgram (program.getProgram());
1429 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1430 ctx.expectError(GL_NO_ERROR);
1431
1432 if (ivec4_f == -1)
1433 {
1434 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1435 ctx.fail("Failed to retrieve uniform location");
1436 }
1437
1438 std::vector<GLint> data(8);
1439
1440 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1441 ctx.glUseProgram(program.getProgram());
1442 ctx.glUniform1iv(ivec4_f, 2, &data[0]);
1443 ctx.expectError(GL_INVALID_OPERATION);
1444 ctx.glUniform2iv(ivec4_f, 2, &data[0]);
1445 ctx.expectError(GL_INVALID_OPERATION);
1446 ctx.glUniform3iv(ivec4_f, 2, &data[0]);
1447 ctx.expectError(GL_INVALID_OPERATION);
1448 ctx.glUniform4iv(ivec4_f, 2, &data[0]);
1449 ctx.expectError(GL_INVALID_OPERATION);
1450 ctx.endSection();
1451
1452 ctx.glUseProgram(0);
1453 }
1454
1455 // ctx.glUniform{1234}ui
1456
uniformui_invalid_program(NegativeTestContext & ctx)1457 void uniformui_invalid_program (NegativeTestContext& ctx)
1458 {
1459 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1460 ctx.glUseProgram(0);
1461 ctx.glUniform1ui(-1, 0);
1462 ctx.expectError(GL_INVALID_OPERATION);
1463 ctx.glUniform2ui(-1, 0, 0);
1464 ctx.expectError(GL_INVALID_OPERATION);
1465 ctx.glUniform3ui(-1, 0, 0, 0);
1466 ctx.expectError(GL_INVALID_OPERATION);
1467 ctx.glUniform4ui(-1, 0, 0, 0, 0);
1468 ctx.expectError(GL_INVALID_OPERATION);
1469 ctx.endSection();
1470 }
1471
uniformui_incompatible_type(NegativeTestContext & ctx)1472 void uniformui_incompatible_type (NegativeTestContext& ctx)
1473 {
1474 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1475
1476 ctx.glUseProgram(program.getProgram());
1477 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1478 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1479 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1480 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1481 ctx.expectError(GL_NO_ERROR);
1482
1483 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1484 {
1485 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1486 ctx.fail("Failed to retrieve uniform location");
1487 }
1488
1489 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1490 ctx.glUseProgram(program.getProgram());
1491 ctx.glUniform1ui(uvec4_f, 0);
1492 ctx.expectError(GL_INVALID_OPERATION);
1493 ctx.glUniform2ui(uvec4_f, 0, 0);
1494 ctx.expectError(GL_INVALID_OPERATION);
1495 ctx.glUniform3ui(uvec4_f, 0, 0, 0);
1496 ctx.expectError(GL_INVALID_OPERATION);
1497 ctx.glUniform4ui(uvec4_f, 0, 0, 0, 0);
1498 ctx.expectError(GL_NO_ERROR);
1499 ctx.endSection();
1500
1501 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type int, ivec2, ivec3, ivec4, or an array of these.");
1502 ctx.glUseProgram(program.getProgram());
1503 ctx.glUniform1ui(ivec4_f, 0);
1504 ctx.expectError(GL_INVALID_OPERATION);
1505 ctx.glUniform2ui(ivec4_f, 0, 0);
1506 ctx.expectError(GL_INVALID_OPERATION);
1507 ctx.glUniform3ui(ivec4_f, 0, 0, 0);
1508 ctx.expectError(GL_INVALID_OPERATION);
1509 ctx.glUniform4ui(ivec4_f, 0, 0, 0, 0);
1510 ctx.expectError(GL_INVALID_OPERATION);
1511 ctx.endSection();
1512
1513 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}i is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1514 ctx.glUseProgram(program.getProgram());
1515 ctx.glUniform1ui(vec4_v, 0);
1516 ctx.expectError(GL_INVALID_OPERATION);
1517 ctx.glUniform2ui(vec4_v, 0, 0);
1518 ctx.expectError(GL_INVALID_OPERATION);
1519 ctx.glUniform3ui(vec4_v, 0, 0, 0);
1520 ctx.expectError(GL_INVALID_OPERATION);
1521 ctx.glUniform4ui(vec4_v, 0, 0, 0, 0);
1522 ctx.expectError(GL_INVALID_OPERATION);
1523 ctx.endSection();
1524
1525 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv.");
1526 ctx.glUseProgram(program.getProgram());
1527 ctx.glUniform1ui(sampler_f, 0);
1528 ctx.expectError(GL_INVALID_OPERATION);
1529 ctx.endSection();
1530
1531 ctx.glUseProgram(0);
1532 }
1533
uniformui_invalid_location(NegativeTestContext & ctx)1534 void uniformui_invalid_location (NegativeTestContext& ctx)
1535 {
1536 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1537
1538 ctx.glUseProgram(program.getProgram());
1539 ctx.expectError(GL_NO_ERROR);
1540
1541 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1542 ctx.glUseProgram(program.getProgram());
1543 ctx.glUniform1i(-2, 0);
1544 ctx.expectError(GL_INVALID_OPERATION);
1545 ctx.glUniform2i(-2, 0, 0);
1546 ctx.expectError(GL_INVALID_OPERATION);
1547 ctx.glUniform3i(-2, 0, 0, 0);
1548 ctx.expectError(GL_INVALID_OPERATION);
1549 ctx.glUniform4i(-2, 0, 0, 0, 0);
1550 ctx.expectError(GL_INVALID_OPERATION);
1551
1552 ctx.glUseProgram(program.getProgram());
1553 ctx.glUniform1i(-1, 0);
1554 ctx.expectError(GL_NO_ERROR);
1555 ctx.glUniform2i(-1, 0, 0);
1556 ctx.expectError(GL_NO_ERROR);
1557 ctx.glUniform3i(-1, 0, 0, 0);
1558 ctx.expectError(GL_NO_ERROR);
1559 ctx.glUniform4i(-1, 0, 0, 0, 0);
1560 ctx.expectError(GL_NO_ERROR);
1561 ctx.endSection();
1562
1563 ctx.glUseProgram(0);
1564 }
1565
1566 // ctx.glUniform{1234}uiv
1567
uniformuiv_invalid_program(NegativeTestContext & ctx)1568 void uniformuiv_invalid_program (NegativeTestContext& ctx)
1569 {
1570 std::vector<GLuint> data(4);
1571
1572 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1573 ctx.glUseProgram(0);
1574 ctx.glUniform1uiv(-1, 1, &data[0]);
1575 ctx.expectError(GL_INVALID_OPERATION);
1576 ctx.glUniform2uiv(-1, 1, &data[0]);
1577 ctx.expectError(GL_INVALID_OPERATION);
1578 ctx.glUniform3uiv(-1, 1, &data[0]);
1579 ctx.expectError(GL_INVALID_OPERATION);
1580 ctx.glUniform4uiv(-1, 1, &data[0]);
1581 ctx.expectError(GL_INVALID_OPERATION);
1582 ctx.endSection();
1583 }
1584
uniformuiv_incompatible_type(NegativeTestContext & ctx)1585 void uniformuiv_incompatible_type (NegativeTestContext& ctx)
1586 {
1587 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1588
1589 ctx.glUseProgram(program.getProgram());
1590 GLint vec4_v = ctx.glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
1591 GLint ivec4_f = ctx.glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
1592 GLint uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1593 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1594 ctx.expectError(GL_NO_ERROR);
1595
1596 if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
1597 {
1598 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1599 ctx.fail("Failed to retrieve uniform location");
1600 }
1601
1602 std::vector<GLuint> data(4);
1603
1604 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1605 ctx.glUseProgram(program.getProgram());
1606 ctx.glUniform1uiv(uvec4_f, 1, &data[0]);
1607 ctx.expectError(GL_INVALID_OPERATION);
1608 ctx.glUniform2uiv(uvec4_f, 1, &data[0]);
1609 ctx.expectError(GL_INVALID_OPERATION);
1610 ctx.glUniform3uiv(uvec4_f, 1, &data[0]);
1611 ctx.expectError(GL_INVALID_OPERATION);
1612 ctx.glUniform4uiv(uvec4_f, 1, &data[0]);
1613 ctx.expectError(GL_NO_ERROR);
1614 ctx.endSection();
1615
1616 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}uiv is used to load a uniform variable of type float, vec2, vec3, or vec4.");
1617 ctx.glUseProgram(program.getProgram());
1618 ctx.glUniform1uiv(vec4_v, 1, &data[0]);
1619 ctx.expectError(GL_INVALID_OPERATION);
1620 ctx.glUniform2uiv(vec4_v, 1, &data[0]);
1621 ctx.expectError(GL_INVALID_OPERATION);
1622 ctx.glUniform3uiv(vec4_v, 1, &data[0]);
1623 ctx.expectError(GL_INVALID_OPERATION);
1624 ctx.glUniform4uiv(vec4_v, 1, &data[0]);
1625 ctx.expectError(GL_INVALID_OPERATION);
1626 ctx.endSection();
1627
1628 ctx.beginSection("GL_INVALID_OPERATION is generated if ctx.glUniform{1234}uiv is used to load a uniform variable of type int, ivec2, ivec3 or ivec4.");
1629 ctx.glUseProgram(program.getProgram());
1630 ctx.glUniform1uiv(ivec4_f, 1, &data[0]);
1631 ctx.expectError(GL_INVALID_OPERATION);
1632 ctx.glUniform2uiv(ivec4_f, 1, &data[0]);
1633 ctx.expectError(GL_INVALID_OPERATION);
1634 ctx.glUniform3uiv(ivec4_f, 1, &data[0]);
1635 ctx.expectError(GL_INVALID_OPERATION);
1636 ctx.glUniform4uiv(ivec4_f, 1, &data[0]);
1637 ctx.expectError(GL_INVALID_OPERATION);
1638 ctx.endSection();
1639
1640 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv.");
1641 ctx.glUseProgram(program.getProgram());
1642 ctx.glUniform1uiv(sampler_f, 1, &data[0]);
1643 ctx.expectError(GL_INVALID_OPERATION);
1644 ctx.endSection();
1645
1646 ctx.glUseProgram(0);
1647 }
1648
uniformuiv_invalid_location(NegativeTestContext & ctx)1649 void uniformuiv_invalid_location (NegativeTestContext& ctx)
1650 {
1651 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1652
1653 ctx.glUseProgram(program.getProgram());
1654 ctx.expectError(GL_NO_ERROR);
1655
1656 std::vector<GLuint> data(4);
1657
1658 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1659 ctx.glUseProgram(program.getProgram());
1660 ctx.glUniform1uiv(-2, 1, &data[0]);
1661 ctx.expectError(GL_INVALID_OPERATION);
1662 ctx.glUniform2uiv(-2, 1, &data[0]);
1663 ctx.expectError(GL_INVALID_OPERATION);
1664 ctx.glUniform3uiv(-2, 1, &data[0]);
1665 ctx.expectError(GL_INVALID_OPERATION);
1666 ctx.glUniform4uiv(-2, 1, &data[0]);
1667 ctx.expectError(GL_INVALID_OPERATION);
1668
1669 ctx.glUseProgram(program.getProgram());
1670 ctx.glUniform1uiv(-1, 1, &data[0]);
1671 ctx.expectError(GL_NO_ERROR);
1672 ctx.glUniform2uiv(-1, 1, &data[0]);
1673 ctx.expectError(GL_NO_ERROR);
1674 ctx.glUniform3uiv(-1, 1, &data[0]);
1675 ctx.expectError(GL_NO_ERROR);
1676 ctx.glUniform4uiv(-1, 1, &data[0]);
1677 ctx.expectError(GL_NO_ERROR);
1678 ctx.endSection();
1679
1680 ctx.glUseProgram(0);
1681 }
1682
uniformuiv_invalid_count(NegativeTestContext & ctx)1683 void uniformuiv_invalid_count (NegativeTestContext& ctx)
1684 {
1685 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1686
1687 ctx.glUseProgram (program.getProgram());
1688 int uvec4_f = ctx.glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
1689 ctx.expectError(GL_NO_ERROR);
1690
1691 if (uvec4_f == -1)
1692 {
1693 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1694 ctx.fail("Failed to retrieve uniform location");
1695 }
1696
1697 std::vector<GLuint> data(8);
1698
1699 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1700 ctx.glUseProgram(program.getProgram());
1701 ctx.glUniform1uiv(uvec4_f, 2, &data[0]);
1702 ctx.expectError(GL_INVALID_OPERATION);
1703 ctx.glUniform2uiv(uvec4_f, 2, &data[0]);
1704 ctx.expectError(GL_INVALID_OPERATION);
1705 ctx.glUniform3uiv(uvec4_f, 2, &data[0]);
1706 ctx.expectError(GL_INVALID_OPERATION);
1707 ctx.glUniform4uiv(uvec4_f, 2, &data[0]);
1708 ctx.expectError(GL_INVALID_OPERATION);
1709 ctx.endSection();
1710
1711 ctx.glUseProgram(0);
1712 }
1713
1714
1715 // ctx.glUniformMatrix*fv
1716
uniform_matrixfv_invalid_program(NegativeTestContext & ctx)1717 void uniform_matrixfv_invalid_program (NegativeTestContext& ctx)
1718 {
1719 std::vector<GLfloat> data(16);
1720
1721 ctx.beginSection("GL_INVALID_OPERATION is generated if there is no current program object.");
1722 ctx.glUseProgram(0);
1723 ctx.glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1724 ctx.expectError(GL_INVALID_OPERATION);
1725 ctx.glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1726 ctx.expectError(GL_INVALID_OPERATION);
1727 ctx.glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1728 ctx.expectError(GL_INVALID_OPERATION);
1729
1730 ctx.glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1731 ctx.expectError(GL_INVALID_OPERATION);
1732 ctx.glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1733 ctx.expectError(GL_INVALID_OPERATION);
1734 ctx.glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1735 ctx.expectError(GL_INVALID_OPERATION);
1736 ctx.glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1737 ctx.expectError(GL_INVALID_OPERATION);
1738 ctx.glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1739 ctx.expectError(GL_INVALID_OPERATION);
1740 ctx.glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1741 ctx.expectError(GL_INVALID_OPERATION);
1742 ctx.endSection();
1743 }
1744
uniform_matrixfv_incompatible_type(NegativeTestContext & ctx)1745 void uniform_matrixfv_incompatible_type (NegativeTestContext& ctx)
1746 {
1747 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1748
1749 ctx.glUseProgram (program.getProgram());
1750 GLint mat4_v = ctx.glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1751 GLint sampler_f = ctx.glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
1752 ctx.expectError(GL_NO_ERROR);
1753
1754 if (mat4_v == -1 || sampler_f == -1)
1755 {
1756 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1757 ctx.fail("Failed to retrieve uniform location");
1758 }
1759
1760 std::vector<GLfloat> data(16);
1761
1762 ctx.beginSection("GL_INVALID_OPERATION is generated if the size of the uniform variable declared in the shader does not match the size indicated by the ctx.glUniform command.");
1763 ctx.glUseProgram(program.getProgram());
1764 ctx.glUniformMatrix2fv(mat4_v, 1, GL_FALSE, &data[0]);
1765 ctx.expectError(GL_INVALID_OPERATION);
1766 ctx.glUniformMatrix3fv(mat4_v, 1, GL_FALSE, &data[0]);
1767 ctx.expectError(GL_INVALID_OPERATION);
1768 ctx.glUniformMatrix4fv(mat4_v, 1, GL_FALSE, &data[0]);
1769 ctx.expectError(GL_NO_ERROR);
1770
1771 ctx.glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1772 ctx.expectError(GL_INVALID_OPERATION);
1773 ctx.glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1774 ctx.expectError(GL_INVALID_OPERATION);
1775 ctx.glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1776 ctx.expectError(GL_INVALID_OPERATION);
1777 ctx.glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1778 ctx.expectError(GL_INVALID_OPERATION);
1779 ctx.glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1780 ctx.expectError(GL_INVALID_OPERATION);
1781 ctx.glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1782 ctx.expectError(GL_INVALID_OPERATION);
1783 ctx.endSection();
1784
1785 ctx.beginSection("GL_INVALID_OPERATION is generated if a sampler is loaded using a command other than ctx.glUniform1i and ctx.glUniform1iv.");
1786 ctx.glUseProgram(program.getProgram());
1787 ctx.glUniformMatrix2fv(sampler_f, 1, GL_FALSE, &data[0]);
1788 ctx.expectError(GL_INVALID_OPERATION);
1789 ctx.glUniformMatrix3fv(sampler_f, 1, GL_FALSE, &data[0]);
1790 ctx.expectError(GL_INVALID_OPERATION);
1791 ctx.glUniformMatrix4fv(sampler_f, 1, GL_FALSE, &data[0]);
1792 ctx.expectError(GL_INVALID_OPERATION);
1793
1794 ctx.glUniformMatrix2x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1795 ctx.expectError(GL_INVALID_OPERATION);
1796 ctx.glUniformMatrix3x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1797 ctx.expectError(GL_INVALID_OPERATION);
1798 ctx.glUniformMatrix2x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1799 ctx.expectError(GL_INVALID_OPERATION);
1800 ctx.glUniformMatrix4x2fv(sampler_f, 1, GL_FALSE, &data[0]);
1801 ctx.expectError(GL_INVALID_OPERATION);
1802 ctx.glUniformMatrix3x4fv(sampler_f, 1, GL_FALSE, &data[0]);
1803 ctx.expectError(GL_INVALID_OPERATION);
1804 ctx.glUniformMatrix4x3fv(sampler_f, 1, GL_FALSE, &data[0]);
1805 ctx.expectError(GL_INVALID_OPERATION);
1806 ctx.endSection();
1807
1808 ctx.glUseProgram(0);
1809 }
1810
uniform_matrixfv_invalid_location(NegativeTestContext & ctx)1811 void uniform_matrixfv_invalid_location (NegativeTestContext& ctx)
1812 {
1813 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1814
1815 ctx.glUseProgram(program.getProgram());
1816 ctx.expectError(GL_NO_ERROR);
1817
1818 std::vector<GLfloat> data(16);
1819
1820 ctx.beginSection("GL_INVALID_OPERATION is generated if location is an invalid uniform location for the current program object and location is not equal to -1.");
1821 ctx.glUseProgram(program.getProgram());
1822 ctx.glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
1823 ctx.expectError(GL_INVALID_OPERATION);
1824 ctx.glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
1825 ctx.expectError(GL_INVALID_OPERATION);
1826 ctx.glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
1827 ctx.expectError(GL_INVALID_OPERATION);
1828
1829 ctx.glUniformMatrix2x3fv(-2, 1, GL_FALSE, &data[0]);
1830 ctx.expectError(GL_INVALID_OPERATION);
1831 ctx.glUniformMatrix3x2fv(-2, 1, GL_FALSE, &data[0]);
1832 ctx.expectError(GL_INVALID_OPERATION);
1833 ctx.glUniformMatrix2x4fv(-2, 1, GL_FALSE, &data[0]);
1834 ctx.expectError(GL_INVALID_OPERATION);
1835 ctx.glUniformMatrix4x2fv(-2, 1, GL_FALSE, &data[0]);
1836 ctx.expectError(GL_INVALID_OPERATION);
1837 ctx.glUniformMatrix3x4fv(-2, 1, GL_FALSE, &data[0]);
1838 ctx.expectError(GL_INVALID_OPERATION);
1839 ctx.glUniformMatrix4x3fv(-2, 1, GL_FALSE, &data[0]);
1840 ctx.expectError(GL_INVALID_OPERATION);
1841
1842 ctx.glUseProgram(program.getProgram());
1843 ctx.glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
1844 ctx.expectError(GL_NO_ERROR);
1845 ctx.glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
1846 ctx.expectError(GL_NO_ERROR);
1847 ctx.glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
1848 ctx.expectError(GL_NO_ERROR);
1849
1850 ctx.glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
1851 ctx.expectError(GL_NO_ERROR);
1852 ctx.glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
1853 ctx.expectError(GL_NO_ERROR);
1854 ctx.glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
1855 ctx.expectError(GL_NO_ERROR);
1856 ctx.glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
1857 ctx.expectError(GL_NO_ERROR);
1858 ctx.glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
1859 ctx.expectError(GL_NO_ERROR);
1860 ctx.glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
1861 ctx.expectError(GL_NO_ERROR);
1862 ctx.endSection();
1863
1864 ctx.glUseProgram(0);
1865 }
1866
uniform_matrixfv_invalid_count(NegativeTestContext & ctx)1867 void uniform_matrixfv_invalid_count (NegativeTestContext& ctx)
1868 {
1869 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
1870
1871 ctx.glUseProgram (program.getProgram());
1872 GLint mat4_v = ctx.glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
1873 ctx.expectError(GL_NO_ERROR);
1874
1875 if (mat4_v == -1)
1876 {
1877 ctx.getLog() << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
1878 ctx.fail("Failed to retrieve uniform location");
1879 }
1880
1881 std::vector<GLfloat> data(32);
1882
1883 ctx.beginSection("GL_INVALID_OPERATION is generated if count is greater than 1 and the indicated uniform variable is not an array variable.");
1884 ctx.glUseProgram(program.getProgram());
1885 ctx.glUniformMatrix2fv(mat4_v, 2, GL_FALSE, &data[0]);
1886 ctx.expectError(GL_INVALID_OPERATION);
1887 ctx.glUniformMatrix3fv(mat4_v, 2, GL_FALSE, &data[0]);
1888 ctx.expectError(GL_INVALID_OPERATION);
1889 ctx.glUniformMatrix4fv(mat4_v, 2, GL_FALSE, &data[0]);
1890 ctx.expectError(GL_INVALID_OPERATION);
1891
1892 ctx.glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1893 ctx.expectError(GL_INVALID_OPERATION);
1894 ctx.glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1895 ctx.expectError(GL_INVALID_OPERATION);
1896 ctx.glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1897 ctx.expectError(GL_INVALID_OPERATION);
1898 ctx.glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
1899 ctx.expectError(GL_INVALID_OPERATION);
1900 ctx.glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
1901 ctx.expectError(GL_INVALID_OPERATION);
1902 ctx.glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
1903 ctx.expectError(GL_INVALID_OPERATION);
1904 ctx.endSection();
1905
1906 ctx.glUseProgram(0);
1907 }
1908
1909 // Transform feedback
gen_transform_feedbacks(NegativeTestContext & ctx)1910 void gen_transform_feedbacks (NegativeTestContext& ctx)
1911 {
1912 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1913 GLuint id = 0;
1914 ctx.glGenTransformFeedbacks(-1, &id);
1915 ctx.expectError(GL_INVALID_VALUE);
1916 ctx.endSection();
1917 }
1918
bind_transform_feedback(NegativeTestContext & ctx)1919 void bind_transform_feedback (NegativeTestContext& ctx)
1920 {
1921 GLuint tfID[2];
1922 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1923 deUint32 buf = 0x1234;
1924 const char* tfVarying = "gl_Position";
1925
1926 ctx.glGenBuffers (1, &buf);
1927 ctx.glGenTransformFeedbacks (2, tfID);
1928
1929 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK.");
1930 ctx.glBindTransformFeedback(-1, tfID[0]);
1931 ctx.expectError(GL_INVALID_ENUM);
1932 ctx.endSection();
1933
1934 ctx.beginSection("GL_INVALID_OPERATION is generated if the transform feedback operation is active on the currently bound transform feedback object, and is not paused.");
1935 ctx.glUseProgram (program.getProgram());
1936 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1937 ctx.glLinkProgram (program.getProgram());
1938 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
1939 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1940 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1941 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1942 ctx.glBeginTransformFeedback (GL_TRIANGLES);
1943 ctx.expectError (GL_NO_ERROR);
1944
1945 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[1]);
1946 ctx.expectError (GL_INVALID_OPERATION);
1947
1948 ctx.glEndTransformFeedback ();
1949 ctx.expectError (GL_NO_ERROR);
1950 ctx.endSection();
1951
1952 ctx.glUseProgram (0);
1953 ctx.glDeleteBuffers (1, &buf);
1954 ctx.glDeleteTransformFeedbacks (2, tfID);
1955 ctx.expectError (GL_NO_ERROR);
1956
1957 ctx.beginSection("GL_INVALID_OPERATION is generated if id has been deleted with glDeleteTransformFeedback().");
1958 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
1959 ctx.expectError(GL_INVALID_OPERATION);
1960 ctx.endSection();
1961
1962 ctx.beginSection("GL_INVALID_OPERATION is generated if id is not 0 or a value returned from glGenTransformFeedbacks().");
1963 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, -1);
1964 ctx.expectError(GL_INVALID_OPERATION);
1965 ctx.endSection();
1966 }
1967
delete_transform_feedbacks(NegativeTestContext & ctx)1968 void delete_transform_feedbacks (NegativeTestContext& ctx)
1969 {
1970 GLuint id = 0;
1971 GLuint tfID[2];
1972 deUint32 buf = 0x1234;
1973 const char* tfVarying = "gl_Position";
1974 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
1975
1976 ctx.glGenBuffers(1, &buf);
1977 ctx.glGenTransformFeedbacks(1, &id);
1978 ctx.glGenTransformFeedbacks(2, tfID);
1979
1980 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1981 ctx.glDeleteTransformFeedbacks(-1, &id);
1982 ctx.expectError(GL_INVALID_VALUE);
1983 ctx.endSection();
1984
1985 ctx.beginSection("GL_INVALID_OPERATION is generated if the transform feedback operation for any object named by ids is currently active.");
1986 ctx.glUseProgram(program.getProgram());
1987 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
1988 ctx.glLinkProgram(program.getProgram());
1989 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
1990 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
1991 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
1992 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
1993 ctx.glBeginTransformFeedback(GL_TRIANGLES);
1994 ctx.expectError(GL_NO_ERROR);
1995
1996 ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[1]);
1997 ctx.expectError(GL_INVALID_OPERATION);
1998
1999 ctx.glDeleteTransformFeedbacks(2, tfID);
2000 ctx.expectError(GL_INVALID_OPERATION);
2001
2002 ctx.glEndTransformFeedback();
2003 ctx.expectError(GL_NO_ERROR);
2004 ctx.endSection();
2005
2006
2007 ctx.glDeleteTransformFeedbacks(1, &id);
2008 ctx.glDeleteTransformFeedbacks(2, tfID);
2009 ctx.glDeleteBuffers(1, &buf);
2010
2011 }
2012
begin_transform_feedback(NegativeTestContext & ctx)2013 void begin_transform_feedback (NegativeTestContext& ctx)
2014 {
2015 GLuint tfID[2];
2016 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2017 deUint32 buf = 0x1234;
2018 const char* tfVarying = "gl_Position";
2019
2020 ctx.glGenBuffers (1, &buf);
2021 ctx.glGenTransformFeedbacks (2, tfID);
2022
2023 ctx.glUseProgram (program.getProgram());
2024 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2025 ctx.glLinkProgram (program.getProgram());
2026 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
2027 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
2028 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
2029 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
2030 ctx.expectError (GL_NO_ERROR);
2031
2032 ctx.beginSection("GL_INVALID_ENUM is generated if primitiveMode is not one of GL_POINTS, GL_LINES, or GL_TRIANGLES.");
2033 ctx.glBeginTransformFeedback (-1);
2034 ctx.expectError (GL_INVALID_ENUM);
2035 ctx.endSection();
2036
2037 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is already active.");
2038 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2039 ctx.expectError (GL_NO_ERROR);
2040 ctx.glBeginTransformFeedback (GL_POINTS);
2041 ctx.expectError (GL_INVALID_OPERATION);
2042 ctx.endSection();
2043
2044 ctx.beginSection("GL_INVALID_OPERATION is generated if any binding point used in transform feedback mode does not have a buffer object bound.");
2045 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
2046 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2047 ctx.expectError (GL_INVALID_OPERATION);
2048 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
2049 ctx.endSection();
2050
2051 ctx.beginSection("GL_INVALID_OPERATION is generated if no binding points would be used because no program object is active.");
2052 ctx.glUseProgram (0);
2053 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2054 ctx.expectError (GL_INVALID_OPERATION);
2055 ctx.glUseProgram (program.getProgram());
2056 ctx.endSection();
2057
2058 ctx.beginSection("GL_INVALID_OPERATION is generated if no binding points would be used because the active program object has specified no varying variables to record.");
2059 ctx.glTransformFeedbackVaryings (program.getProgram(), 0, 0, GL_INTERLEAVED_ATTRIBS);
2060 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2061 ctx.expectError (GL_INVALID_OPERATION);
2062 ctx.endSection();
2063
2064 ctx.glEndTransformFeedback ();
2065 ctx.glDeleteBuffers (1, &buf);
2066 ctx.glDeleteTransformFeedbacks (2, tfID);
2067 ctx.expectError (GL_NO_ERROR);
2068 }
2069
pause_transform_feedback(NegativeTestContext & ctx)2070 void pause_transform_feedback (NegativeTestContext& ctx)
2071 {
2072 GLuint tfID[2];
2073 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2074 deUint32 buf = 0x1234;
2075 const char* tfVarying = "gl_Position";
2076
2077 ctx.glGenBuffers (1, &buf);
2078 ctx.glGenTransformFeedbacks (2, tfID);
2079
2080 ctx.glUseProgram (program.getProgram());
2081 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2082 ctx.glLinkProgram (program.getProgram());
2083 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
2084 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
2085 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
2086 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
2087 ctx.expectError (GL_NO_ERROR);
2088
2089 ctx.beginSection("GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is paused.");
2090 ctx.glPauseTransformFeedback ();
2091 ctx.expectError (GL_INVALID_OPERATION);
2092 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2093 ctx.glPauseTransformFeedback ();
2094 ctx.expectError (GL_NO_ERROR);
2095 ctx.glPauseTransformFeedback ();
2096 ctx.expectError (GL_INVALID_OPERATION);
2097 ctx.endSection();
2098
2099 ctx.glEndTransformFeedback ();
2100 ctx.glDeleteBuffers (1, &buf);
2101 ctx.glDeleteTransformFeedbacks (2, tfID);
2102 ctx.expectError (GL_NO_ERROR);
2103 }
2104
resume_transform_feedback(NegativeTestContext & ctx)2105 void resume_transform_feedback (NegativeTestContext& ctx)
2106 {
2107 GLuint tfID[2];
2108 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2109 deUint32 buf = 0x1234;
2110 const char* tfVarying = "gl_Position";
2111
2112 ctx.glGenBuffers (1, &buf);
2113 ctx.glGenTransformFeedbacks (2, tfID);
2114
2115 ctx.glUseProgram (program.getProgram());
2116 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2117 ctx.glLinkProgram (program.getProgram());
2118 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID[0]);
2119 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
2120 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
2121 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
2122 ctx.expectError (GL_NO_ERROR);
2123
2124 ctx.beginSection("GL_INVALID_OPERATION is generated if the currently bound transform feedback object is not active or is not paused.");
2125 ctx.glResumeTransformFeedback ();
2126 ctx.expectError (GL_INVALID_OPERATION);
2127 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2128 ctx.glResumeTransformFeedback ();
2129 ctx.expectError (GL_INVALID_OPERATION);
2130 ctx.glPauseTransformFeedback ();
2131 ctx.glResumeTransformFeedback ();
2132 ctx.expectError (GL_NO_ERROR);
2133 ctx.endSection();
2134
2135 ctx.glEndTransformFeedback ();
2136 ctx.glDeleteBuffers (1, &buf);
2137 ctx.glDeleteTransformFeedbacks (2, tfID);
2138 ctx.expectError (GL_NO_ERROR);
2139 }
2140
end_transform_feedback(NegativeTestContext & ctx)2141 void end_transform_feedback (NegativeTestContext& ctx)
2142 {
2143 GLuint tfID = 0;
2144 glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2145 deUint32 buf = 0x1234;
2146 const char* tfVarying = "gl_Position";
2147
2148 ctx.glGenBuffers (1, &buf);
2149 ctx.glGenTransformFeedbacks (1, &tfID);
2150
2151 ctx.glUseProgram (program.getProgram());
2152 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2153 ctx.glLinkProgram (program.getProgram());
2154 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
2155 ctx.glBindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
2156 ctx.glBufferData (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
2157 ctx.glBindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
2158 ctx.expectError (GL_NO_ERROR);
2159
2160 ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is not active.");
2161 ctx.glEndTransformFeedback ();
2162 ctx.expectError (GL_INVALID_OPERATION);
2163 ctx.glBeginTransformFeedback (GL_TRIANGLES);
2164 ctx.glEndTransformFeedback ();
2165 ctx.expectError (GL_NO_ERROR);
2166 ctx.endSection();
2167
2168 ctx.glDeleteBuffers (1, &buf);
2169 ctx.glDeleteTransformFeedbacks (1, &tfID);
2170 ctx.expectError (GL_NO_ERROR);
2171 }
2172
get_transform_feedback_varying(NegativeTestContext & ctx)2173 void get_transform_feedback_varying (NegativeTestContext& ctx)
2174 {
2175 GLuint tfID = 0;
2176 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2177 glu::ShaderProgram programInvalid (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, ""));
2178 const char* tfVarying = "gl_Position";
2179 int maxTransformFeedbackVaryings = 0;
2180
2181 GLsizei length;
2182 GLsizei size;
2183 GLenum type;
2184 char name[32];
2185
2186 const GLuint notAProgram = ctx.glCreateProgram();
2187 ctx.glDeleteProgram(notAProgram);
2188
2189 ctx.glGenTransformFeedbacks (1, &tfID);
2190
2191 ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2192 ctx.expectError (GL_NO_ERROR);
2193 ctx.glLinkProgram (program.getProgram());
2194 ctx.expectError (GL_NO_ERROR);
2195
2196 ctx.glBindTransformFeedback (GL_TRANSFORM_FEEDBACK, tfID);
2197 ctx.expectError (GL_NO_ERROR);
2198
2199 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object.");
2200 ctx.glGetTransformFeedbackVarying (notAProgram, 0, 32, &length, &size, &type, &name[0]);
2201 ctx.expectError (GL_INVALID_VALUE);
2202 ctx.endSection();
2203
2204 ctx.beginSection("GL_INVALID_VALUE is generated if index is greater or equal to the value of GL_TRANSFORM_FEEDBACK_VARYINGS.");
2205 ctx.glGetProgramiv (program.getProgram(), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxTransformFeedbackVaryings);
2206 ctx.glGetTransformFeedbackVarying (program.getProgram(), maxTransformFeedbackVaryings, 32, &length, &size, &type, &name[0]);
2207 ctx.expectError (GL_INVALID_VALUE);
2208 ctx.endSection();
2209
2210 ctx.beginSection("GL_INVALID_OPERATION or GL_INVALID_VALUE is generated program has not been linked.");
2211 ctx.glGetTransformFeedbackVarying (programInvalid.getProgram(), 0, 32, &length, &size, &type, &name[0]);
2212 ctx.expectError (GL_INVALID_OPERATION, GL_INVALID_VALUE);
2213 ctx.endSection();
2214
2215 ctx.glDeleteTransformFeedbacks (1, &tfID);
2216 ctx.expectError (GL_NO_ERROR);
2217 }
2218
transform_feedback_varyings(NegativeTestContext & ctx)2219 void transform_feedback_varyings (NegativeTestContext& ctx)
2220 {
2221 GLuint tfID = 0;
2222 GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
2223 glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
2224 const char* tfVarying = "gl_Position";
2225 GLint maxTransformFeedbackSeparateAttribs = 0;
2226
2227 const GLuint notAProgram = ctx.glCreateProgram();
2228 ctx.glDeleteProgram(notAProgram);
2229
2230 ctx.glGenTransformFeedbacks (1, &tfID);
2231 ctx.expectError (GL_NO_ERROR);
2232
2233 ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of a program object.");
2234 ctx.glTransformFeedbackVaryings (notAProgram, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2235 ctx.expectError (GL_INVALID_VALUE);
2236 ctx.endSection();
2237
2238 ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
2239 ctx.glTransformFeedbackVaryings(shader, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2240 ctx.expectError(GL_INVALID_OPERATION);
2241 ctx.glDeleteShader(shader);
2242 ctx.endSection();
2243
2244 ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
2245 ctx.glTransformFeedbackVaryings(program.getProgram(), -1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
2246 ctx.expectError(GL_INVALID_VALUE);
2247 ctx.endSection();
2248
2249 ctx.beginSection("GL_INVALID_ENUM is generated if bufferMode is not SEPARATE_ATTRIBS or INTERLEAVED_ATTRIBS.");
2250 ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, 0);
2251 ctx.expectError(GL_INVALID_ENUM);
2252 ctx.endSection();
2253
2254 ctx.beginSection("GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
2255 ctx.glGetIntegerv (GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
2256 ctx.glTransformFeedbackVaryings (program.getProgram(), maxTransformFeedbackSeparateAttribs+1, &tfVarying, GL_SEPARATE_ATTRIBS);
2257 ctx.expectError (GL_INVALID_VALUE);
2258 ctx.endSection();
2259
2260 ctx.glDeleteTransformFeedbacks (1, &tfID);
2261 ctx.expectError (GL_NO_ERROR);
2262
2263 }
2264
link_compute_shader(NegativeTestContext & ctx)2265 void link_compute_shader (NegativeTestContext& ctx)
2266 {
2267 const char* computeShaderSource = "#version 320 es\n"
2268 "void main (void)\n"
2269 "{\n"
2270 "}\n\0";
2271 {
2272 const GLenum shaderTypes[] = {
2273 GL_VERTEX_SHADER,
2274 GL_FRAGMENT_SHADER,
2275 GL_GEOMETRY_SHADER,
2276 GL_TESS_CONTROL_SHADER,
2277 GL_TESS_EVALUATION_SHADER
2278 };
2279
2280 ctx.beginSection("Compute Shader linked with shader of other kind.");
2281 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ndx++)
2282 {
2283 GLint linkStatus = -1;
2284 GLuint program = ctx.glCreateProgram();
2285 GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER);
2286 GLuint otherShader = ctx.glCreateShader(shaderTypes[ndx]);
2287 const char* otherShaderSource = (shaderTypes[ndx] != GL_GEOMETRY_SHADER) ?
2288 computeShaderSource :
2289 "#version 320 es\n"
2290 "layout(max_vertices = 3) out;\n"
2291 "void main(void){}\n\0";
2292
2293 ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL);
2294 ctx.glShaderSource(otherShader, 1, &otherShaderSource, DE_NULL);
2295 ctx.glCompileShader(computeShader);
2296 ctx.glCompileShader(otherShader);
2297 ctx.glAttachShader(program, computeShader);
2298 ctx.glAttachShader(program, otherShader);
2299 ctx.glLinkProgram(program);
2300 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
2301 ctx.glDeleteShader(otherShader);
2302 ctx.glDeleteShader(computeShader);
2303 ctx.glDeleteProgram(program);
2304 if (linkStatus != GL_FALSE)
2305 ctx.fail("Program should not have linked");
2306 }
2307 ctx.endSection();
2308 }
2309 {
2310 const char* computeShaderSource310 = "#version 310 es\n"
2311 "void main (void)\n"
2312 "{\n"
2313 "}\n\0";
2314 GLint linkStatus = -1;
2315 GLuint program = ctx.glCreateProgram();
2316 GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER);
2317 GLuint computeShader310 = ctx.glCreateShader(GL_FRAGMENT_SHADER);
2318
2319 ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL);
2320 ctx.glShaderSource(computeShader310, 1, &computeShaderSource310, DE_NULL);
2321 ctx.beginSection("Compute Shader should not be linked with shaders of different version.");
2322 ctx.glCompileShader(computeShader);
2323 ctx.glCompileShader(computeShader310);
2324 ctx.glAttachShader(program, computeShader);
2325 ctx.glAttachShader(program, computeShader310);
2326 ctx.glLinkProgram(program);
2327 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
2328 ctx.glDeleteShader(computeShader310);
2329 ctx.glDeleteShader(computeShader);
2330 ctx.glDeleteProgram(program);
2331 if (linkStatus != GL_FALSE)
2332 ctx.fail("Program should not have linked");
2333 ctx.endSection();
2334 }
2335 }
2336
compile_compute_shader_helper(NegativeTestContext & ctx,const char ** computeShaderSource,GLint * compileStatus)2337 void compile_compute_shader_helper (NegativeTestContext& ctx, const char** computeShaderSource, GLint* compileStatus)
2338 {
2339 GLuint shader = ctx.glCreateShader(GL_COMPUTE_SHADER);
2340
2341 *compileStatus = -1;
2342 ctx.glShaderSource(shader, 1, computeShaderSource, DE_NULL);
2343 ctx.glCompileShader(shader);
2344 ctx.glGetShaderiv(shader, GL_COMPILE_STATUS, compileStatus);
2345 ctx.glDeleteShader(shader);
2346 }
2347
compile_compute_shader(NegativeTestContext & ctx)2348 void compile_compute_shader (NegativeTestContext& ctx)
2349 {
2350 GLint compileStatus;
2351 ctx.beginSection("Compile Computer Shader");
2352
2353 {
2354 const char* computeShaderSource = "#version 300 es\n"
2355 "void main (void)\n"
2356 "{\n"
2357 "}\n\0";
2358
2359 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2360 if (compileStatus != GL_FALSE)
2361 ctx.fail("Compute Shader should not have compiled with #version 300 es.");
2362 }
2363 {
2364 const char* computeShaderSource = "#version 310 es\n"
2365 "buffer SSBO { vec4 data }"
2366 "void main (void)\n"
2367 "{\n"
2368 "}\n\0";
2369
2370 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2371 if (compileStatus != GL_FALSE)
2372 ctx.fail("Compute Shader should not have compiled: incorrect SSBO syntax.");
2373 }
2374 {
2375 const char* computeShaderSource = "#version 310 es\n"
2376 "buffer SSBO { vec4 data;};"
2377 "uniform mat4 data;"
2378 "void main (void)\n"
2379 "{\n"
2380 "}\n\0";
2381
2382 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2383 if (compileStatus != GL_FALSE)
2384 ctx.fail("Compute Shader should not have compiled: buffer variable redefinition.");
2385 }
2386 {
2387 const char* computeShaderSource = "#version 310 es\n"
2388 "buffer SSBO { vec4 data[]; vec4 moreData;};"
2389 "void main (void)\n"
2390 "{\n"
2391 "}\n\0";
2392
2393 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2394 if (compileStatus != GL_FALSE)
2395 ctx.fail("Compute Shader should not have compiled: unspecified length buffer member not at the end.");
2396 }
2397 {
2398 const char* computeShaderSource = "#version 310 es\n"
2399 "in vec4 data;"
2400 "void main (void)\n"
2401 "{\n"
2402 "}\n\0";
2403
2404 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2405 if (compileStatus != GL_FALSE)
2406 ctx.fail("Compute Shader should not have compiled: input qualifier used.");
2407 }
2408 {
2409 const char* computeShaderSource = "#version 310 es\n"
2410 "shared uint data = 0;";
2411
2412 compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
2413 if (compileStatus != GL_FALSE)
2414 ctx.fail("Compute Shader should not have compiled: shared-qualified variable initialized.");
2415 }
2416 ctx.endSection();
2417 }
2418
getNegativeShaderApiTestFunctions()2419 std::vector<FunctionContainer> getNegativeShaderApiTestFunctions ()
2420 {
2421 FunctionContainer funcs[] =
2422 {
2423 {create_shader, "create_shader", "Invalid glCreateShader() usage" },
2424 {shader_source, "shader_source", "Invalid glShaderSource() usage" },
2425 {compile_shader, "compile_shader", "Invalid glCompileShader() usage" },
2426 {delete_shader, "delete_shader", "Invalid glDeleteShader() usage" },
2427 {shader_binary, "shader_binary", "Invalid glShaderBinary() usage" },
2428 {attach_shader, "attach_shader", "Invalid glAttachShader() usage" },
2429 {detach_shader, "detach_shader", "Invalid glDetachShader() usage" },
2430 {link_program, "link_program", "Invalid glLinkProgram() usage" },
2431 {use_program, "use_program", "Invalid glUseProgram() usage" },
2432 {delete_program, "delete_program", "Invalid glDeleteProgram() usage" },
2433 {validate_program, "validate_program", "Invalid glValidateProgram() usage" },
2434 {get_program_binary, "get_program_binary", "Invalid glGetProgramBinary() usage" },
2435 {program_binary, "program_binary", "Invalid glProgramBinary() usage" },
2436 {program_parameteri, "program_parameteri", "Invalid glProgramParameteri() usage" },
2437 {gen_samplers, "gen_samplers", "Invalid glGenSamplers() usage" },
2438 {bind_sampler, "bind_sampler", "Invalid glBindSampler() usage" },
2439 {delete_samplers, "delete_samplers", "Invalid glDeleteSamplers() usage" },
2440 {get_sampler_parameteriv, "get_sampler_parameteriv", "Invalid glGetSamplerParameteriv() usage" },
2441 {get_sampler_parameterfv, "get_sampler_parameterfv", "Invalid glGetSamplerParameterfv() usage" },
2442 {get_sampler_parameterIiv, "get_sampler_parameterIiv", "Invalid glGetSamplerParameterIiv() usage" },
2443 {get_sampler_parameterIuiv, "get_sampler_parameterIuiv", "Invalid glGetSamplerParameterIuiv() usage" },
2444 {sampler_parameteri, "sampler_parameteri", "Invalid glSamplerParameteri() usage" },
2445 {sampler_parameteriv, "sampler_parameteriv", "Invalid glSamplerParameteriv() usage" },
2446 {sampler_parameterf, "sampler_parameterf", "Invalid glSamplerParameterf() usage" },
2447 {sampler_parameterfv, "sampler_parameterfv", "Invalid glSamplerParameterfv() usage" },
2448 {sampler_parameterIiv, "sampler_parameterIiv", "Invalid glSamplerParameterIiv() usage" },
2449 {sampler_parameterIuiv, "sampler_parameterIuiv", "Invalid glSamplerParameterIuiv() usage" },
2450 {get_attrib_location, "get_attrib_location", "Invalid glGetAttribLocation() usage" },
2451 {get_uniform_location, "get_uniform_location", "Invalid glGetUniformLocation() usage" },
2452 {bind_attrib_location, "bind_attrib_location", "Invalid glBindAttribLocation() usage" },
2453 {uniform_block_binding, "uniform_block_binding", "Invalid glUniformBlockBinding() usage" },
2454 {uniformf_invalid_program, "uniformf_invalid_program", "Invalid glUniform{1234}f() usage" },
2455 {uniformf_incompatible_type, "uniformf_incompatible_type", "Invalid glUniform{1234}f() usage" },
2456 {uniformf_invalid_location, "uniformf_invalid_location", "Invalid glUniform{1234}f() usage" },
2457 {uniformfv_invalid_program, "uniformfv_invalid_program", "Invalid glUniform{1234}fv() usage" },
2458 {uniformfv_incompatible_type, "uniformfv_incompatible_type", "Invalid glUniform{1234}fv() usage" },
2459 {uniformfv_invalid_location, "uniformfv_invalid_location", "Invalid glUniform{1234}fv() usage" },
2460 {uniformfv_invalid_count, "uniformfv_invalid_count", "Invalid glUniform{1234}fv() usage" },
2461 {uniformi_invalid_program, "uniformi_invalid_program", "Invalid glUniform{1234}i() usage" },
2462 {uniformi_incompatible_type, "uniformi_incompatible_type", "Invalid glUniform{1234}i() usage" },
2463 {uniformi_invalid_location, "uniformi_invalid_location", "Invalid glUniform{1234}i() usage" },
2464 {uniformiv_invalid_program, "uniformiv_invalid_program", "Invalid glUniform{1234}iv() usage" },
2465 {uniformiv_incompatible_type, "uniformiv_incompatible_type", "Invalid glUniform{1234}iv() usage" },
2466 {uniformiv_invalid_location, "uniformiv_invalid_location", "Invalid glUniform{1234}iv() usage" },
2467 {uniformiv_invalid_count, "uniformiv_invalid_count", "Invalid glUniform{1234}iv() usage" },
2468 {uniformui_invalid_program, "uniformui_invalid_program", "Invalid glUniform{234}ui() usage" },
2469 {uniformui_incompatible_type, "uniformui_incompatible_type", "Invalid glUniform{1234}ui() usage" },
2470 {uniformui_invalid_location, "uniformui_invalid_location", "Invalid glUniform{1234}ui() usage" },
2471 {uniformuiv_invalid_program, "uniformuiv_invalid_program", "Invalid glUniform{234}uiv() usage" },
2472 {uniformuiv_incompatible_type, "uniformuiv_incompatible_type", "Invalid glUniform{1234}uiv() usage" },
2473 {uniformuiv_invalid_location, "uniformuiv_invalid_location", "Invalid glUniform{1234}uiv() usage" },
2474 {uniformuiv_invalid_count, "uniformuiv_invalid_count", "Invalid glUniform{1234}uiv() usage" },
2475 {uniform_matrixfv_invalid_program, "uniform_matrixfv_invalid_program", "Invalid glUniformMatrix{234}fv() usage" },
2476 {uniform_matrixfv_incompatible_type, "uniform_matrixfv_incompatible_type", "Invalid glUniformMatrix{234}fv() usage" },
2477 {uniform_matrixfv_invalid_location, "uniform_matrixfv_invalid_location", "Invalid glUniformMatrix{234}fv() usage" },
2478 {uniform_matrixfv_invalid_count, "uniform_matrixfv_invalid_count", "Invalid glUniformMatrix{234}fv() usage" },
2479 {gen_transform_feedbacks, "gen_transform_feedbacks", "Invalid glGenTransformFeedbacks() usage" },
2480 {bind_transform_feedback, "bind_transform_feedback", "Invalid glBindTransformFeedback() usage" },
2481 {delete_transform_feedbacks, "delete_transform_feedbacks", "Invalid glDeleteTransformFeedbacks() usage" },
2482 {begin_transform_feedback, "begin_transform_feedback", "Invalid glBeginTransformFeedback() usage" },
2483 {pause_transform_feedback, "pause_transform_feedback", "Invalid glPauseTransformFeedback() usage" },
2484 {resume_transform_feedback, "resume_transform_feedback", "Invalid glResumeTransformFeedback() usage" },
2485 {end_transform_feedback, "end_transform_feedback", "Invalid glEndTransformFeedback() usage" },
2486 {get_transform_feedback_varying, "get_transform_feedback_varying", "Invalid glGetTransformFeedbackVarying() usage"},
2487 {transform_feedback_varyings, "transform_feedback_varyings", "Invalid glTransformFeedbackVaryings() usage" },
2488 {compile_compute_shader, "compile_compute_shader", "Invalid Compute Shader compilation" },
2489 {link_compute_shader, "link_compute_shader", "Invalid Compute Shader linkage" },
2490 };
2491
2492 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
2493 }
2494
2495 } // NegativeTestShared
2496 } // Functional
2497 } // gles31
2498 } // deqp
2499