1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2016 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 Function Tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "es31fNegativeShaderFunctionTests.hpp"
25
26 #include "gluShaderProgram.hpp"
27
28 namespace deqp
29 {
30 namespace gles31
31 {
32 namespace Functional
33 {
34 namespace NegativeTestShared
35 {
36 namespace
37 {
38
39 enum ShaderFunction
40 {
41 SHADER_FUNCTION_BITFIELD_REVERSE = 0,
42 SHADER_FUNCTION_BIT_COUNT,
43 SHADER_FUNCTION_FIND_MSB,
44 SHADER_FUNCTION_FIND_LSB,
45 SHADER_FUNCTION_UADD_CARRY,
46 SHADER_FUNCTION_USUB_BORROW,
47 SHADER_FUNCTION_UMUL_EXTENDED,
48 SHADER_FUNCTION_IMUL_EXTENDED,
49 SHADER_FUNCTION_FREXP,
50 SHADER_FUNCTION_LDEXP,
51 SHADER_FUNCTION_PACK_UNORM_4X8,
52 SHADER_FUNCTION_PACK_SNORM_4X8,
53 SHADER_FUNCTION_UNPACK_SNORM_4X8,
54 SHADER_FUNCTION_UNPACK_UNORM_4X8,
55 SHADER_FUNCTION_EMIT_VERTEX,
56 SHADER_FUNCTION_END_PRIMITIVE,
57 SHADER_FUNCTION_ATOMIC_ADD,
58 SHADER_FUNCTION_ATOMIC_MIN,
59 SHADER_FUNCTION_ATOMIC_MAX,
60 SHADER_FUNCTION_ATOMIC_AND,
61 SHADER_FUNCTION_ATOMIC_OR,
62 SHADER_FUNCTION_ATOMIC_XOR,
63 SHADER_FUNCTION_ATOMIC_EXCHANGE,
64 SHADER_FUNCTION_ATOMIC_COMP_SWAP,
65 SHADER_FUNCTION_INTERPOLATED_AT_CENTROID,
66 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
67 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
68
69 SHADER_FUNCTION_LAST
70 };
71
72 enum FunctionTextureModes
73 {
74 FUNCTION_TEXTURE_MODE_NO_BIAS_NO_COMPARE = 0,
75 FUNCTION_TEXTURE_MODE_BIAS_OR_COMPARE,
76
77 FUNCTION_TEXTURE_MODE_LAST
78 };
79
80 enum FunctionTextureGatherOffsetModes
81 {
82 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP = 0,
83 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
84
85 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_LAST
86 };
87
88 struct TextureGatherOffsetsTestSpec
89 {
90 FunctionTextureGatherOffsetModes mode;
91 glu::DataType samplerDataType;
92 glu::DataType pDataType;
93 glu::DataType offsetsDataType;
94 glu::DataType fourthArgument;
95 bool offsetIsConst;
96 int offsetArraySize;
97 };
98
99 static const glu::DataType s_floatTypes[] = {glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT_VEC3,
100 glu::TYPE_FLOAT_VEC4};
101
102 static const glu::DataType s_intTypes[] = {glu::TYPE_INT, glu::TYPE_INT_VEC2, glu::TYPE_INT_VEC3, glu::TYPE_INT_VEC4};
103
104 static const glu::DataType s_uintTypes[] = {glu::TYPE_UINT, glu::TYPE_UINT_VEC2, glu::TYPE_UINT_VEC3,
105 glu::TYPE_UINT_VEC4};
106
107 static const glu::DataType s_nonScalarIntTypes[] = {glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT_VEC3,
108 glu::TYPE_FLOAT_VEC4, glu::TYPE_INT_VEC2, glu::TYPE_INT_VEC3,
109 glu::TYPE_INT_VEC4, glu::TYPE_UINT, glu::TYPE_UINT_VEC2,
110 glu::TYPE_UINT_VEC3, glu::TYPE_UINT_VEC4};
111
112 static const glu::ShaderType s_shaders[] = {glu::SHADERTYPE_VERTEX,
113 glu::SHADERTYPE_FRAGMENT,
114 glu::SHADERTYPE_GEOMETRY,
115 glu::SHADERTYPE_TESSELLATION_CONTROL,
116 glu::SHADERTYPE_TESSELLATION_EVALUATION,
117 glu::SHADERTYPE_COMPUTE};
118
119 static const glu::DataType s_samplerTypes[] = {
120 glu::TYPE_SAMPLER_2D,
121 glu::TYPE_INT_SAMPLER_2D,
122 glu::TYPE_UINT_SAMPLER_2D,
123 glu::TYPE_SAMPLER_3D,
124 glu::TYPE_INT_SAMPLER_3D,
125 glu::TYPE_UINT_SAMPLER_3D,
126 glu::TYPE_SAMPLER_CUBE,
127 glu::TYPE_INT_SAMPLER_CUBE,
128 glu::TYPE_UINT_SAMPLER_CUBE,
129 glu::TYPE_SAMPLER_2D_ARRAY,
130 glu::TYPE_INT_SAMPLER_2D_ARRAY,
131 glu::TYPE_UINT_SAMPLER_2D_ARRAY,
132 glu::TYPE_SAMPLER_CUBE_SHADOW,
133 glu::TYPE_SAMPLER_2D_SHADOW,
134 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
135 glu::TYPE_SAMPLER_CUBE_ARRAY,
136 glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
137 glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
138 glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
139
140 glu::TYPE_SAMPLER_2D_MULTISAMPLE,
141 glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
142 glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
143
144 glu::TYPE_SAMPLER_BUFFER,
145 glu::TYPE_INT_SAMPLER_BUFFER,
146 glu::TYPE_UINT_SAMPLER_BUFFER,
147
148 glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
149 glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
150 glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
151 };
152
verifyShader(NegativeTestContext & ctx,glu::ShaderType shaderType,std::string shaderSource)153 void verifyShader(NegativeTestContext &ctx, glu::ShaderType shaderType, std::string shaderSource)
154 {
155 tcu::TestLog &log = ctx.getLog();
156 const char *source = shaderSource.c_str();
157 const int length = (int)shaderSource.size();
158 glu::Shader shader(ctx.getRenderContext(), shaderType);
159
160 shader.setSources(1, &source, &length);
161 shader.compile();
162
163 log << shader;
164 if (shader.getCompileStatus())
165 {
166 log << tcu::TestLog::Message << "Expected shader to fail, but compilation passed." << tcu::TestLog::EndMessage;
167 ctx.fail("Shader was not expected to compile.\n");
168 }
169 }
170
declareAndInitializeShaderVariable(glu::DataType dataType,std::string varName)171 std::string declareAndInitializeShaderVariable(glu::DataType dataType, std::string varName)
172 {
173 std::ostringstream variable;
174 variable << getDataTypeName(dataType) << " " << varName << " = " << getDataTypeName(dataType);
175 switch (dataType)
176 {
177 case glu::TYPE_FLOAT:
178 variable << "(1.0);\n";
179 break;
180 case glu::TYPE_FLOAT_VEC2:
181 variable << "(1.0, 1.0);\n";
182 break;
183 case glu::TYPE_FLOAT_VEC3:
184 variable << "(1.0, 1.0, 1.0);\n";
185 break;
186 case glu::TYPE_FLOAT_VEC4:
187 variable << "(1.0, 1.0, 1.0, 1.0);\n";
188 break;
189 case glu::TYPE_INT:
190 variable << "(1);\n";
191 break;
192 case glu::TYPE_INT_VEC2:
193 variable << "(1, 1);\n";
194 break;
195 case glu::TYPE_INT_VEC3:
196 variable << "(1, 1, 1);\n";
197 break;
198 case glu::TYPE_INT_VEC4:
199 variable << "(1, 1, 1, 1);\n";
200 break;
201 case glu::TYPE_UINT:
202 variable << "(1u);\n";
203 break;
204 case glu::TYPE_UINT_VEC2:
205 variable << "(1u, 1u);\n";
206 break;
207 case glu::TYPE_UINT_VEC3:
208 variable << "(1u, 1u, 1u);\n";
209 break;
210 case glu::TYPE_UINT_VEC4:
211 variable << "(1u, 1u, 1u, 1u);\n";
212 break;
213 default:
214 DE_FATAL("Unsupported data type.");
215 }
216 return variable.str();
217 }
218
declareShaderUniform(glu::DataType dataType,std::string varName)219 std::string declareShaderUniform(glu::DataType dataType, std::string varName)
220 {
221 std::ostringstream variable;
222 variable << getPrecisionName(glu::PRECISION_HIGHP) << " uniform " << getDataTypeName(dataType) << " " << varName
223 << ";\n";
224 return variable.str();
225 }
226
declareShaderInput(glu::DataType dataType,std::string varName)227 std::string declareShaderInput(glu::DataType dataType, std::string varName)
228 {
229 std::ostringstream variable;
230 variable << "in " << getPrecisionName(glu::PRECISION_HIGHP) << " " << getDataTypeName(dataType) << " " << varName
231 << ";\n";
232 return variable.str();
233 }
234
declareBuffer(glu::DataType dataType,std::string varName)235 std::string declareBuffer(glu::DataType dataType, std::string varName)
236 {
237 std::ostringstream variable;
238 variable << "buffer SSBO {\n"
239 << " " << getDataTypeName(dataType) << " " << varName << ";\n"
240 << "};\n";
241 return variable.str();
242 }
243
declareShaderArrayVariable(glu::DataType dataType,std::string varName,const int arraySize)244 std::string declareShaderArrayVariable(glu::DataType dataType, std::string varName, const int arraySize)
245 {
246 std::ostringstream source;
247 source << getDataTypeName(dataType) << " " << varName << "[" << arraySize << "]"
248 << " = " << getDataTypeName(dataType) << "[](";
249
250 for (int ndx = 0; ndx < arraySize; ++ndx)
251 source << getDataTypeName(dataType) << "(" << 0 << ", " << 0 << ")" << ((ndx < arraySize - 1) ? ", " : "");
252
253 source << ");";
254 return source.str();
255 }
256
getShaderExtensionDeclaration(std::string extension)257 std::string getShaderExtensionDeclaration(std::string extension)
258 {
259 if (extension.empty())
260 return std::string("");
261 else
262 {
263 std::ostringstream source;
264 source << "#extension " << extension << " : enable\n";
265 return source.str();
266 }
267 }
268
getDataTypeExtension(glu::DataType dataType)269 std::string getDataTypeExtension(glu::DataType dataType)
270 {
271 std::ostringstream source;
272 switch (dataType)
273 {
274 case glu::TYPE_SAMPLER_CUBE_ARRAY:
275 case glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW:
276 case glu::TYPE_INT_SAMPLER_CUBE_ARRAY:
277 case glu::TYPE_UINT_SAMPLER_CUBE_ARRAY:
278 source << "GL_EXT_texture_cube_map_array";
279 break;
280
281 case glu::TYPE_SAMPLER_BUFFER:
282 case glu::TYPE_INT_SAMPLER_BUFFER:
283 case glu::TYPE_UINT_SAMPLER_BUFFER:
284 source << "GL_EXT_texture_buffer";
285 break;
286
287 case glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY:
288 case glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
289 case glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY:
290 source << "GL_OES_texture_storage_multisample_2d_array";
291 break;
292
293 default:
294 break;
295 }
296
297 return source.str();
298 }
299
getShaderInitialization(NegativeTestContext & ctx,glu::ShaderType shaderType)300 std::string getShaderInitialization(NegativeTestContext &ctx, glu::ShaderType shaderType)
301 {
302 std::ostringstream source;
303
304 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
305 {
306 switch (shaderType)
307 {
308 case glu::SHADERTYPE_GEOMETRY:
309 source << "#extension GL_EXT_geometry_shader : enable\n";
310 break;
311
312 case glu::SHADERTYPE_TESSELLATION_CONTROL:
313 source << "#extension GL_EXT_tessellation_shader : enable\n";
314 break;
315
316 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
317 source << "#extension GL_EXT_tessellation_shader : enable\n";
318 break;
319
320 default:
321 break;
322 }
323 }
324
325 switch (shaderType)
326 {
327 case glu::SHADERTYPE_GEOMETRY:
328 source << "layout(max_vertices = 5) out;\n";
329 break;
330
331 case glu::SHADERTYPE_TESSELLATION_CONTROL:
332 source << "layout(vertices = 3) out;\n";
333 break;
334
335 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
336 source << "layout(triangles, equal_spacing, cw) in;\n";
337 break;
338
339 default:
340 break;
341 }
342
343 return source.str();
344 }
345
genShaderSourceBitfieldExtract(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType valueDataType,glu::DataType offsetDataType,glu::DataType bitsDataType)346 std::string genShaderSourceBitfieldExtract(NegativeTestContext &ctx, glu::ShaderType shaderType,
347 glu::DataType valueDataType, glu::DataType offsetDataType,
348 glu::DataType bitsDataType)
349 {
350 std::ostringstream source;
351 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
352 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
353 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
354 << "\n"
355 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
356 << "{\n"
357 << " " << declareAndInitializeShaderVariable(valueDataType, "value") << " "
358 << declareAndInitializeShaderVariable(offsetDataType, "offset") << " "
359 << declareAndInitializeShaderVariable(bitsDataType, "bits") << " bitfieldExtract(value, offset, bits);\n"
360 << "}\n";
361
362 return source.str();
363 }
364
bitfield_extract_invalid_value_type(NegativeTestContext & ctx)365 void bitfield_extract_invalid_value_type(NegativeTestContext &ctx)
366 {
367 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
368
369 ctx.beginSection("bitfieldExtract: Invalid value type.");
370 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
371 {
372 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
373 {
374 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
375 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
376 {
377 const std::string shaderSource(genShaderSourceBitfieldExtract(
378 ctx, s_shaders[shaderNdx], s_floatTypes[dataTypeNdx], glu::TYPE_INT, glu::TYPE_INT));
379 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
380 }
381 ctx.endSection();
382 }
383 }
384 ctx.endSection();
385 }
386
bitfield_extract_invalid_offset_type(NegativeTestContext & ctx)387 void bitfield_extract_invalid_offset_type(NegativeTestContext &ctx)
388 {
389 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
390
391 ctx.beginSection("bitfieldExtract: Invalid offset type.");
392 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
393 {
394 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
395 {
396 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
397 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
398 {
399 for (int nonIntNdx = 0; nonIntNdx < DE_LENGTH_OF_ARRAY(s_nonScalarIntTypes); ++nonIntNdx)
400 {
401 {
402 const std::string shaderSource(
403 genShaderSourceBitfieldExtract(ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx],
404 s_nonScalarIntTypes[nonIntNdx], glu::TYPE_INT));
405 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
406 }
407 {
408 const std::string shaderSource(
409 genShaderSourceBitfieldExtract(ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx],
410 s_nonScalarIntTypes[nonIntNdx], glu::TYPE_INT));
411 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
412 }
413 }
414 }
415 ctx.endSection();
416 }
417 }
418 ctx.endSection();
419 }
420
bitfield_extract_invalid_bits_type(NegativeTestContext & ctx)421 void bitfield_extract_invalid_bits_type(NegativeTestContext &ctx)
422 {
423 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
424
425 ctx.beginSection("bitfieldExtract: Invalid bits type.");
426 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
427 {
428 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
429 {
430 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
431 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
432 {
433 for (int nonIntNdx = 0; nonIntNdx < DE_LENGTH_OF_ARRAY(s_nonScalarIntTypes); ++nonIntNdx)
434 {
435 {
436 const std::string shaderSource(
437 genShaderSourceBitfieldExtract(ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx],
438 glu::TYPE_INT, s_nonScalarIntTypes[nonIntNdx]));
439 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
440 }
441 {
442 const std::string shaderSource(
443 genShaderSourceBitfieldExtract(ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx],
444 glu::TYPE_INT, s_nonScalarIntTypes[nonIntNdx]));
445 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
446 }
447 }
448 }
449 ctx.endSection();
450 }
451 }
452 ctx.endSection();
453 }
454
genShaderSourceBitfieldInsert(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType baseDataType,glu::DataType insertDataType,glu::DataType offsetDataType,glu::DataType bitsDataType)455 std::string genShaderSourceBitfieldInsert(NegativeTestContext &ctx, glu::ShaderType shaderType,
456 glu::DataType baseDataType, glu::DataType insertDataType,
457 glu::DataType offsetDataType, glu::DataType bitsDataType)
458 {
459 std::ostringstream source;
460 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
461 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
462 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
463 << "\n"
464 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
465 << "{\n"
466 << " " << declareAndInitializeShaderVariable(baseDataType, "base") << " "
467 << declareAndInitializeShaderVariable(insertDataType, "insert") << " "
468 << declareAndInitializeShaderVariable(offsetDataType, "offset") << " "
469 << declareAndInitializeShaderVariable(bitsDataType, "bits")
470 << " bitfieldInsert(base, insert, offset, bits);\n"
471 << "}\n";
472
473 return source.str();
474 }
475
bitfield_insert_invalid_base_type(NegativeTestContext & ctx)476 void bitfield_insert_invalid_base_type(NegativeTestContext &ctx)
477 {
478 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
479 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_floatTypes));
480
481 ctx.beginSection("bitfieldInsert: Invalid base type.");
482 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
483 {
484 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
485 {
486 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
487 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
488 {
489 {
490 const std::string shaderSource(
491 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_floatTypes[dataTypeNdx],
492 s_intTypes[dataTypeNdx], glu::TYPE_INT, glu::TYPE_INT));
493 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
494 }
495 {
496 const std::string shaderSource(
497 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_floatTypes[dataTypeNdx],
498 s_uintTypes[dataTypeNdx], glu::TYPE_INT, glu::TYPE_INT));
499 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
500 }
501 }
502 ctx.endSection();
503 }
504 }
505 ctx.endSection();
506 }
507
bitfield_insert_invalid_insert_type(NegativeTestContext & ctx)508 void bitfield_insert_invalid_insert_type(NegativeTestContext &ctx)
509 {
510 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
511 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_floatTypes));
512
513 ctx.beginSection("bitfieldInsert: Invalid insert type.");
514 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
515 {
516 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
517 {
518 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
519 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
520 {
521 {
522 const std::string shaderSource(
523 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx],
524 s_floatTypes[dataTypeNdx], glu::TYPE_INT, glu::TYPE_INT));
525 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
526 }
527 {
528 const std::string shaderSource(
529 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx],
530 s_floatTypes[dataTypeNdx], glu::TYPE_INT, glu::TYPE_INT));
531 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
532 }
533
534 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx2)
535 {
536 if (s_intTypes[dataTypeNdx] == s_intTypes[dataTypeNdx2])
537 continue;
538
539 {
540 const std::string shaderSource(
541 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx],
542 s_intTypes[dataTypeNdx2], glu::TYPE_INT, glu::TYPE_INT));
543 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
544 }
545 {
546 const std::string shaderSource(
547 genShaderSourceBitfieldInsert(ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx],
548 s_uintTypes[dataTypeNdx2], glu::TYPE_INT, glu::TYPE_INT));
549 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
550 }
551 }
552 }
553 ctx.endSection();
554 }
555 }
556 ctx.endSection();
557 }
558
bitfield_insert_invalid_offset_type(NegativeTestContext & ctx)559 void bitfield_insert_invalid_offset_type(NegativeTestContext &ctx)
560 {
561 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
562
563 ctx.beginSection("bitfieldInsert: Invalid offset type.");
564 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
565 {
566 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
567 {
568 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
569 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
570 {
571 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_nonScalarIntTypes); ++dataTypeNdx2)
572 {
573 {
574 const std::string shaderSource(genShaderSourceBitfieldInsert(
575 ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx],
576 s_nonScalarIntTypes[dataTypeNdx2], glu::TYPE_INT));
577 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
578 }
579 {
580 const std::string shaderSource(genShaderSourceBitfieldInsert(
581 ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx],
582 s_nonScalarIntTypes[dataTypeNdx2], glu::TYPE_INT));
583 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
584 }
585 }
586 }
587 ctx.endSection();
588 }
589 }
590 ctx.endSection();
591 }
592
bitfield_insert_invalid_bits_type(NegativeTestContext & ctx)593 void bitfield_insert_invalid_bits_type(NegativeTestContext &ctx)
594 {
595 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_intTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
596
597 ctx.beginSection("bitfieldInsert: Invalid bits type.");
598 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
599 {
600 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
601 {
602 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
603 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
604 {
605 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_nonScalarIntTypes); ++dataTypeNdx2)
606 {
607 {
608 const std::string shaderSource(genShaderSourceBitfieldInsert(
609 ctx, s_shaders[shaderNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], glu::TYPE_INT,
610 s_nonScalarIntTypes[dataTypeNdx2]));
611 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
612 }
613 {
614 const std::string shaderSource(genShaderSourceBitfieldInsert(
615 ctx, s_shaders[shaderNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx],
616 glu::TYPE_INT, s_nonScalarIntTypes[dataTypeNdx2]));
617 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
618 }
619 }
620 }
621 ctx.endSection();
622 }
623 }
624 ctx.endSection();
625 }
626
627 // bitfieldReverse, bitCount, findMSB, findLSB
genShaderSourceReverseCountFind(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType baseDataType)628 std::string genShaderSourceReverseCountFind(NegativeTestContext &ctx, glu::ShaderType shaderType,
629 ShaderFunction function, glu::DataType baseDataType)
630 {
631 DE_ASSERT(function == SHADER_FUNCTION_BITFIELD_REVERSE || function == SHADER_FUNCTION_BIT_COUNT ||
632 function == SHADER_FUNCTION_FIND_MSB || function == SHADER_FUNCTION_FIND_LSB);
633
634 std::ostringstream source;
635 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
636 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
637 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
638 << "\n"
639 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
640 << "{\n"
641 << " " << declareAndInitializeShaderVariable(baseDataType, "value");
642
643 switch (function)
644 {
645 case SHADER_FUNCTION_BITFIELD_REVERSE:
646 source << " bitfieldReverse(value);\n";
647 break;
648 case SHADER_FUNCTION_BIT_COUNT:
649 source << " bitCount(value);\n";
650 break;
651 case SHADER_FUNCTION_FIND_MSB:
652 source << " findMSB(value);\n";
653 break;
654 case SHADER_FUNCTION_FIND_LSB:
655 source << " findLSB(value);\n";
656 break;
657 default:
658 DE_FATAL("Unsupported shader function.");
659 }
660
661 source << "}\n";
662
663 return source.str();
664 }
665
bitfield_reverse(NegativeTestContext & ctx)666 void bitfield_reverse(NegativeTestContext &ctx)
667 {
668 ctx.beginSection("bitfieldReverse: Invalid value type.");
669 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
670 {
671 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
672 {
673 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
674 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
675 {
676 const std::string shaderSource(genShaderSourceReverseCountFind(
677 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_BITFIELD_REVERSE, s_floatTypes[dataTypeNdx]));
678 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
679 }
680 ctx.endSection();
681 }
682 }
683 ctx.endSection();
684 }
685
bit_count(NegativeTestContext & ctx)686 void bit_count(NegativeTestContext &ctx)
687 {
688 ctx.beginSection("bitCount: Invalid value type.");
689 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
690 {
691 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
692 {
693 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
694 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
695 {
696 const std::string shaderSource(genShaderSourceReverseCountFind(
697 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_BIT_COUNT, s_floatTypes[dataTypeNdx]));
698 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
699 }
700 ctx.endSection();
701 }
702 }
703 ctx.endSection();
704 }
705
find_msb(NegativeTestContext & ctx)706 void find_msb(NegativeTestContext &ctx)
707 {
708 ctx.beginSection("findMSB: Invalid value type.");
709 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
710 {
711 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
712 {
713 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
714 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
715 {
716 const std::string shaderSource(genShaderSourceReverseCountFind(
717 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FIND_MSB, s_floatTypes[dataTypeNdx]));
718 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
719 }
720 ctx.endSection();
721 }
722 }
723 ctx.endSection();
724 }
725
find_lsb(NegativeTestContext & ctx)726 void find_lsb(NegativeTestContext &ctx)
727 {
728 ctx.beginSection("findLSB: Invalid value type.");
729 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
730 {
731 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
732 {
733 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
734 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
735 {
736 const std::string shaderSource(genShaderSourceReverseCountFind(
737 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FIND_LSB, s_floatTypes[dataTypeNdx]));
738 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
739 }
740 ctx.endSection();
741 }
742 }
743 ctx.endSection();
744 }
745
746 // uaddCarry, usubBorrow
genShaderSourceAddCarrySubBorrow(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType xDataType,glu::DataType yDataType,glu::DataType carryBorrowDataType)747 std::string genShaderSourceAddCarrySubBorrow(NegativeTestContext &ctx, glu::ShaderType shaderType,
748 ShaderFunction function, glu::DataType xDataType, glu::DataType yDataType,
749 glu::DataType carryBorrowDataType)
750 {
751 DE_ASSERT(function == SHADER_FUNCTION_UADD_CARRY || function == SHADER_FUNCTION_USUB_BORROW);
752
753 std::ostringstream source;
754 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
755 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
756 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
757 << "\n"
758 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
759 << "{\n"
760 << " " << declareAndInitializeShaderVariable(xDataType, "x") << " "
761 << declareAndInitializeShaderVariable(yDataType, "y");
762
763 switch (function)
764 {
765 case SHADER_FUNCTION_UADD_CARRY:
766 source << " " << declareAndInitializeShaderVariable(carryBorrowDataType, "carry")
767 << " uaddCarry(x, y, carry);\n";
768 break;
769
770 case SHADER_FUNCTION_USUB_BORROW:
771 source << " " << declareAndInitializeShaderVariable(carryBorrowDataType, "borrow")
772 << " usubBorrow(x, y, borrow);\n";
773 break;
774
775 default:
776 DE_FATAL("Unsupported shader function.");
777 }
778
779 source << "}\n";
780
781 return source.str();
782 }
783
uadd_carry_invalid_x(NegativeTestContext & ctx)784 void uadd_carry_invalid_x(NegativeTestContext &ctx)
785 {
786 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
787 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
788
789 ctx.beginSection("uaddCarry: Invalid x type.");
790 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
791 {
792 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
793 {
794 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
795 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
796 {
797 {
798 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
799 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_floatTypes[dataTypeNdx],
800 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
801 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
802 }
803 {
804 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
805 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_intTypes[dataTypeNdx],
806 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
807 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
808 }
809 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
810 {
811 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
812 continue;
813
814 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
815 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx2],
816 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
817 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
818 }
819 }
820 ctx.endSection();
821 }
822 }
823 ctx.endSection();
824 }
825
uadd_carry_invalid_y(NegativeTestContext & ctx)826 void uadd_carry_invalid_y(NegativeTestContext &ctx)
827 {
828 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
829 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
830
831 ctx.beginSection("uaddCarry: Invalid y type.");
832 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
833 {
834 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
835 {
836 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
837 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
838 {
839 {
840 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
841 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
842 s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
843 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
844 }
845 {
846 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
847 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
848 s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
849 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
850 }
851
852 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
853 {
854 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
855 continue;
856
857 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
858 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
859 s_uintTypes[dataTypeNdx2], s_uintTypes[dataTypeNdx]));
860 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
861 }
862 }
863 ctx.endSection();
864 }
865 }
866 ctx.endSection();
867 }
868
uadd_carry_invalid_carry(NegativeTestContext & ctx)869 void uadd_carry_invalid_carry(NegativeTestContext &ctx)
870 {
871 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
872 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
873
874 ctx.beginSection("uaddCarry: Invalid carry type.");
875 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
876 {
877 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
878 {
879 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
880 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
881 {
882 {
883 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
884 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
885 s_uintTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
886 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
887 }
888 {
889 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
890 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
891 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
892 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
893 }
894
895 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
896 {
897 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
898 continue;
899
900 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
901 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UADD_CARRY, s_uintTypes[dataTypeNdx],
902 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx2]));
903 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
904 }
905 }
906 ctx.endSection();
907 }
908 }
909 ctx.endSection();
910 }
911
usub_borrow_invalid_x(NegativeTestContext & ctx)912 void usub_borrow_invalid_x(NegativeTestContext &ctx)
913 {
914 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
915 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
916
917 ctx.beginSection("usubBorrow: Invalid x type.");
918 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
919 {
920 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
921 {
922 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
923 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
924 {
925 {
926 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
927 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_floatTypes[dataTypeNdx],
928 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
929 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
930 }
931 {
932 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
933 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_intTypes[dataTypeNdx],
934 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
935 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
936 }
937
938 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
939 {
940 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
941 continue;
942
943 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
944 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx2],
945 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
946 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
947 }
948 }
949 ctx.endSection();
950 }
951 }
952 ctx.endSection();
953 }
954
usub_borrow_invalid_y(NegativeTestContext & ctx)955 void usub_borrow_invalid_y(NegativeTestContext &ctx)
956 {
957 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
958 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
959
960 ctx.beginSection("usubBorrow: Invalid y type.");
961 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
962 {
963 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
964 {
965 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
966 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
967 {
968 {
969 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
970 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
971 s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
972 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
973 }
974 {
975 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
976 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
977 s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
978 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
979 }
980
981 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
982 {
983 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
984 continue;
985
986 const std::string shaderSource = genShaderSourceAddCarrySubBorrow(
987 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
988 s_uintTypes[dataTypeNdx2], s_uintTypes[dataTypeNdx]);
989 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
990 }
991 }
992 ctx.endSection();
993 }
994 }
995 ctx.endSection();
996 }
997
usub_borrow_invalid_borrow(NegativeTestContext & ctx)998 void usub_borrow_invalid_borrow(NegativeTestContext &ctx)
999 {
1000 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1001 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1002
1003 ctx.beginSection("usubBorrow: Invalid borrow type.");
1004 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1005 {
1006 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1007 {
1008 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1009 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1010 {
1011 {
1012 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
1013 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
1014 s_uintTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
1015 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1016 }
1017 {
1018 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
1019 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
1020 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1021 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1022 }
1023
1024 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx2)
1025 {
1026 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
1027 continue;
1028
1029 const std::string shaderSource(genShaderSourceAddCarrySubBorrow(
1030 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_USUB_BORROW, s_uintTypes[dataTypeNdx],
1031 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx2]));
1032 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1033 }
1034 }
1035 ctx.endSection();
1036 }
1037 }
1038 ctx.endSection();
1039 }
1040
1041 // umulExtended, imulExtended
genShaderSourceMulExtended(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType xDataType,glu::DataType yDataType,glu::DataType msbDataType,glu::DataType lsbDataType)1042 std::string genShaderSourceMulExtended(NegativeTestContext &ctx, glu::ShaderType shaderType, ShaderFunction function,
1043 glu::DataType xDataType, glu::DataType yDataType, glu::DataType msbDataType,
1044 glu::DataType lsbDataType)
1045 {
1046 DE_ASSERT(function == SHADER_FUNCTION_UMUL_EXTENDED || function == SHADER_FUNCTION_IMUL_EXTENDED);
1047
1048 std::ostringstream source;
1049 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1050 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1051 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1052 << "\n"
1053 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
1054 << "{\n"
1055 << " " << declareAndInitializeShaderVariable(xDataType, "x") << " "
1056 << declareAndInitializeShaderVariable(yDataType, "y") << " "
1057 << declareAndInitializeShaderVariable(msbDataType, "msb") << " "
1058 << declareAndInitializeShaderVariable(lsbDataType, "lsb");
1059
1060 switch (function)
1061 {
1062 case SHADER_FUNCTION_UMUL_EXTENDED:
1063 source << " umulExtended(x, y, msb, lsb);\n";
1064 break;
1065 case SHADER_FUNCTION_IMUL_EXTENDED:
1066 source << " imulExtended(x, y, msb, lsb);\n";
1067 break;
1068 default:
1069 DE_FATAL("Unsupported shader function.");
1070 }
1071
1072 source << "}\n";
1073
1074 return source.str();
1075 }
1076
umul_extended_invalid_x(NegativeTestContext & ctx)1077 void umul_extended_invalid_x(NegativeTestContext &ctx)
1078 {
1079 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1080 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1081
1082 ctx.beginSection("umulExtended: Invalid x type.");
1083 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1084 {
1085 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1086 {
1087 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1088 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1089 {
1090 {
1091 const std::string shaderSource(genShaderSourceMulExtended(
1092 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_floatTypes[dataTypeNdx],
1093 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1094 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1095 }
1096 {
1097 const std::string shaderSource(genShaderSourceMulExtended(
1098 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_intTypes[dataTypeNdx],
1099 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1100 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1101 }
1102
1103 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx2)
1104 {
1105 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
1106 continue;
1107
1108 const std::string shaderSource(genShaderSourceMulExtended(
1109 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx2],
1110 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1111 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1112 }
1113 }
1114 ctx.endSection();
1115 }
1116 }
1117 ctx.endSection();
1118 }
1119
umul_extended_invalid_y(NegativeTestContext & ctx)1120 void umul_extended_invalid_y(NegativeTestContext &ctx)
1121 {
1122 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1123 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1124
1125 ctx.beginSection("umulExtended: Invalid y type.");
1126 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1127 {
1128 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1129 {
1130 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1131 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1132 {
1133 {
1134 const std::string shaderSource(genShaderSourceMulExtended(
1135 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1136 s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1137 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1138 }
1139 {
1140 const std::string shaderSource(genShaderSourceMulExtended(
1141 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1142 s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1143 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1144 }
1145
1146 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx2)
1147 {
1148 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
1149 continue;
1150
1151 const std::string shaderSource(genShaderSourceMulExtended(
1152 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1153 s_uintTypes[dataTypeNdx2], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1154 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1155 }
1156 }
1157 ctx.endSection();
1158 }
1159 }
1160 ctx.endSection();
1161 }
1162
umul_extended_invalid_msb(NegativeTestContext & ctx)1163 void umul_extended_invalid_msb(NegativeTestContext &ctx)
1164 {
1165 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1166 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1167
1168 ctx.beginSection("umulExtended: Invalid msb type.");
1169 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1170 {
1171 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1172 {
1173 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1174 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1175 {
1176 {
1177 const std::string shaderSource(genShaderSourceMulExtended(
1178 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1179 s_uintTypes[dataTypeNdx], s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1180 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1181 }
1182 {
1183 const std::string shaderSource(genShaderSourceMulExtended(
1184 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1185 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1186 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1187 }
1188
1189 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx2)
1190 {
1191 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
1192 continue;
1193
1194 const std::string shaderSource(genShaderSourceMulExtended(
1195 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1196 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx2], s_uintTypes[dataTypeNdx]));
1197 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1198 }
1199 }
1200 ctx.endSection();
1201 }
1202 }
1203 ctx.endSection();
1204 }
1205
umul_extended_invalid_lsb(NegativeTestContext & ctx)1206 void umul_extended_invalid_lsb(NegativeTestContext &ctx)
1207 {
1208 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1209 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1210
1211 ctx.beginSection("umulExtended: Invalid lsb type.");
1212 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1213 {
1214 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1215 {
1216 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1217 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1218 {
1219 {
1220 const std::string shaderSource(genShaderSourceMulExtended(
1221 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1222 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
1223 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1224 }
1225 {
1226 const std::string shaderSource(genShaderSourceMulExtended(
1227 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1228 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1229 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1230 }
1231
1232 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx2)
1233 {
1234 if (s_uintTypes[dataTypeNdx2] == s_uintTypes[dataTypeNdx])
1235 continue;
1236
1237 const std::string shaderSource(genShaderSourceMulExtended(
1238 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1239 s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_uintTypes[dataTypeNdx2]));
1240 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1241 }
1242 }
1243 ctx.endSection();
1244 }
1245 }
1246 ctx.endSection();
1247 }
1248
imul_extended_invalid_x(NegativeTestContext & ctx)1249 void imul_extended_invalid_x(NegativeTestContext &ctx)
1250 {
1251 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1252 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1253
1254 ctx.beginSection("imulExtended: Invalid x type.");
1255 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1256 {
1257 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1258 {
1259 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1260 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1261 {
1262 {
1263 const std::string shaderSource(genShaderSourceMulExtended(
1264 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_floatTypes[dataTypeNdx],
1265 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1266 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1267 }
1268 {
1269 const std::string shaderSource(genShaderSourceMulExtended(
1270 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_uintTypes[dataTypeNdx],
1271 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1272 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1273 }
1274
1275 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx2)
1276 {
1277 if (s_intTypes[dataTypeNdx2] == s_intTypes[dataTypeNdx])
1278 continue;
1279
1280 const std::string shaderSource(genShaderSourceMulExtended(
1281 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx2],
1282 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1283 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1284 }
1285 }
1286 ctx.endSection();
1287 }
1288 }
1289 ctx.endSection();
1290 }
1291
imul_extended_invalid_y(NegativeTestContext & ctx)1292 void imul_extended_invalid_y(NegativeTestContext &ctx)
1293 {
1294 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1295 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1296
1297 ctx.beginSection("imulExtended: Invalid y type.");
1298 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1299 {
1300 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1301 {
1302 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1303 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1304 {
1305 {
1306 const std::string shaderSource(genShaderSourceMulExtended(
1307 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1308 s_floatTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1309 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1310 }
1311 {
1312 const std::string shaderSource(genShaderSourceMulExtended(
1313 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1314 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1315 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1316 }
1317
1318 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx2)
1319 {
1320 if (s_intTypes[dataTypeNdx2] == s_intTypes[dataTypeNdx])
1321 continue;
1322
1323 const std::string shaderSource(genShaderSourceMulExtended(
1324 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1325 s_intTypes[dataTypeNdx2], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1326 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1327 }
1328 }
1329 ctx.endSection();
1330 }
1331 }
1332 ctx.endSection();
1333 }
1334
imul_extended_invalid_msb(NegativeTestContext & ctx)1335 void imul_extended_invalid_msb(NegativeTestContext &ctx)
1336 {
1337 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1338 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1339
1340 ctx.beginSection("imulExtended: Invalid msb type.");
1341 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1342 {
1343 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1344 {
1345 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1346 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1347 {
1348 {
1349 const std::string shaderSource(genShaderSourceMulExtended(
1350 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1351 s_intTypes[dataTypeNdx], s_floatTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1352 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1353 }
1354 {
1355 const std::string shaderSource(genShaderSourceMulExtended(
1356 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1357 s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1358 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1359 }
1360
1361 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx2)
1362 {
1363 if (s_intTypes[dataTypeNdx2] == s_intTypes[dataTypeNdx])
1364 continue;
1365
1366 const std::string shaderSource(genShaderSourceMulExtended(
1367 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1368 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx2], s_intTypes[dataTypeNdx]));
1369 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1370 }
1371 }
1372 ctx.endSection();
1373 }
1374 }
1375 ctx.endSection();
1376 }
1377
imul_extended_invalid_lsb(NegativeTestContext & ctx)1378 void imul_extended_invalid_lsb(NegativeTestContext &ctx)
1379 {
1380 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1381 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1382
1383 ctx.beginSection("imulExtended: Invalid lsb type.");
1384 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1385 {
1386 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1387 {
1388 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1389 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1390 {
1391 {
1392 const std::string shaderSource(genShaderSourceMulExtended(
1393 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1394 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
1395 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1396 }
1397 {
1398 const std::string shaderSource(genShaderSourceMulExtended(
1399 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1400 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1401 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1402 }
1403
1404 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx2)
1405 {
1406 if (s_intTypes[dataTypeNdx2] == s_intTypes[dataTypeNdx])
1407 continue;
1408
1409 const std::string shaderSource(genShaderSourceMulExtended(
1410 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_IMUL_EXTENDED, s_intTypes[dataTypeNdx],
1411 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx2]));
1412 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1413 }
1414 }
1415 ctx.endSection();
1416 }
1417 }
1418 ctx.endSection();
1419 }
1420
1421 // frexp, ldexp
genShaderSourceFrexpLdexp(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType xDataType,glu::DataType expDataType)1422 std::string genShaderSourceFrexpLdexp(NegativeTestContext &ctx, glu::ShaderType shaderType, ShaderFunction function,
1423 glu::DataType xDataType, glu::DataType expDataType)
1424 {
1425 DE_ASSERT(function == SHADER_FUNCTION_FREXP || function == SHADER_FUNCTION_LDEXP);
1426
1427 std::ostringstream source;
1428 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1429 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1430 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1431 << "\n"
1432 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
1433 << "{\n"
1434 << " " << declareAndInitializeShaderVariable(xDataType, "x") << " "
1435 << declareAndInitializeShaderVariable(expDataType, "exp");
1436
1437 switch (function)
1438 {
1439 case SHADER_FUNCTION_FREXP:
1440 source << " frexp(x, exp);\n";
1441 break;
1442
1443 case SHADER_FUNCTION_LDEXP:
1444 source << " ldexp(x, exp);\n";
1445 break;
1446
1447 default:
1448 DE_FATAL("Unsupported shader function.");
1449 }
1450
1451 source << "}\n";
1452
1453 return source.str();
1454 }
1455
frexp_invalid_x(NegativeTestContext & ctx)1456 void frexp_invalid_x(NegativeTestContext &ctx)
1457 {
1458 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1459 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1460
1461 ctx.beginSection("frexp: Invalid x type.");
1462 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1463 {
1464 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1465 {
1466 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1467 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1468 {
1469 {
1470 const std::string shaderSource(
1471 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FREXP,
1472 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1473 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1474 }
1475 {
1476 const std::string shaderSource(
1477 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FREXP,
1478 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1479 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1480 }
1481 }
1482 ctx.endSection();
1483 }
1484 }
1485 ctx.endSection();
1486 }
1487
frexp_invalid_exp(NegativeTestContext & ctx)1488 void frexp_invalid_exp(NegativeTestContext &ctx)
1489 {
1490 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1491 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1492
1493 ctx.beginSection("frexp: Invalid exp type.");
1494 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1495 {
1496 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1497 {
1498 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1499 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1500 {
1501 {
1502 const std::string shaderSource(
1503 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FREXP,
1504 s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1505 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1506 }
1507 {
1508 const std::string shaderSource(
1509 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_FREXP,
1510 s_floatTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
1511 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1512 }
1513 }
1514 ctx.endSection();
1515 }
1516 }
1517 ctx.endSection();
1518 }
1519
ldexp_invalid_x(NegativeTestContext & ctx)1520 void ldexp_invalid_x(NegativeTestContext &ctx)
1521 {
1522 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1523 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1524
1525 ctx.beginSection("ldexp: Invalid x type.");
1526 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1527 {
1528 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1529 {
1530 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1531 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1532 {
1533 {
1534 const std::string shaderSource(
1535 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_LDEXP,
1536 s_intTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1537 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1538 }
1539 {
1540 const std::string shaderSource(
1541 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_LDEXP,
1542 s_uintTypes[dataTypeNdx], s_intTypes[dataTypeNdx]));
1543 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1544 }
1545 }
1546 ctx.endSection();
1547 }
1548 }
1549 ctx.endSection();
1550 }
1551
ldexp_invalid_exp(NegativeTestContext & ctx)1552 void ldexp_invalid_exp(NegativeTestContext &ctx)
1553 {
1554 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1555 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1556
1557 ctx.beginSection("ldexp: Invalid exp type.");
1558 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1559 {
1560 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1561 {
1562 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1563 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1564 {
1565 {
1566 const std::string shaderSource(
1567 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_LDEXP,
1568 s_floatTypes[dataTypeNdx], s_uintTypes[dataTypeNdx]));
1569 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1570 }
1571 {
1572 const std::string shaderSource(
1573 genShaderSourceFrexpLdexp(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_LDEXP,
1574 s_floatTypes[dataTypeNdx], s_floatTypes[dataTypeNdx]));
1575 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1576 }
1577 }
1578 ctx.endSection();
1579 }
1580 }
1581 ctx.endSection();
1582 }
1583
1584 // packUnorm4x8, packSnorm4x8, unpackSnorm4x8, unpackUnorm4x8
genShaderSourcePackUnpackNorm4x8(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType dataType)1585 std::string genShaderSourcePackUnpackNorm4x8(NegativeTestContext &ctx, glu::ShaderType shaderType,
1586 ShaderFunction function, glu::DataType dataType)
1587 {
1588 DE_ASSERT(function == SHADER_FUNCTION_PACK_UNORM_4X8 || function == SHADER_FUNCTION_PACK_SNORM_4X8 ||
1589 function == SHADER_FUNCTION_UNPACK_SNORM_4X8 || function == SHADER_FUNCTION_UNPACK_UNORM_4X8);
1590
1591 std::ostringstream source;
1592 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1593 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1594 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1595 << "\n"
1596 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
1597 << "{\n";
1598
1599 switch (function)
1600 {
1601 case SHADER_FUNCTION_PACK_UNORM_4X8:
1602 source << " mediump " << declareAndInitializeShaderVariable(dataType, "v") << " packUnorm4x8(v);\n";
1603 break;
1604
1605 case SHADER_FUNCTION_PACK_SNORM_4X8:
1606 source << " mediump " << declareAndInitializeShaderVariable(dataType, "v") << " packSnorm4x8(v);\n";
1607 break;
1608
1609 case SHADER_FUNCTION_UNPACK_SNORM_4X8:
1610 source << " highp " << declareAndInitializeShaderVariable(dataType, "p") << " unpackSnorm4x8(p);\n";
1611 break;
1612
1613 case SHADER_FUNCTION_UNPACK_UNORM_4X8:
1614 source << " highp " << declareAndInitializeShaderVariable(dataType, "p") << " unpackUnorm4x8(p);\n";
1615 break;
1616
1617 default:
1618 DE_FATAL("Unsupported shader function.");
1619 }
1620
1621 source << "}\n";
1622
1623 return source.str();
1624 }
1625
pack_unorm_4x8(NegativeTestContext & ctx)1626 void pack_unorm_4x8(NegativeTestContext &ctx)
1627 {
1628 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1629 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1630
1631 ctx.beginSection("packUnorm4x8: Invalid v type.");
1632 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1633 {
1634 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1635 {
1636 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1637 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1638 {
1639 if (s_floatTypes[dataTypeNdx] == glu::TYPE_FLOAT_VEC4)
1640 continue;
1641
1642 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1643 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_UNORM_4X8, s_floatTypes[dataTypeNdx]));
1644 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1645 }
1646
1647 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1648 {
1649 {
1650 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1651 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_UNORM_4X8, s_intTypes[dataTypeNdx]));
1652 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1653 }
1654 {
1655 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1656 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_UNORM_4X8, s_uintTypes[dataTypeNdx]));
1657 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1658 }
1659 }
1660 ctx.endSection();
1661 }
1662 }
1663 ctx.endSection();
1664 }
1665
pack_snorm_4x8(NegativeTestContext & ctx)1666 void pack_snorm_4x8(NegativeTestContext &ctx)
1667 {
1668 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1669 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1670
1671 ctx.beginSection("packSnorm4x8: Invalid v type.");
1672 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1673 {
1674 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1675 {
1676 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1677 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1678 {
1679 if (s_floatTypes[dataTypeNdx] == glu::TYPE_FLOAT_VEC4)
1680 continue;
1681
1682 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1683 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_SNORM_4X8, s_floatTypes[dataTypeNdx]));
1684 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1685 }
1686 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1687 {
1688 {
1689 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1690 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_SNORM_4X8, s_intTypes[dataTypeNdx]));
1691 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1692 }
1693 {
1694 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1695 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_PACK_SNORM_4X8, s_uintTypes[dataTypeNdx]));
1696 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1697 }
1698 }
1699 ctx.endSection();
1700 }
1701 }
1702 ctx.endSection();
1703 }
1704
unpack_snorm_4x8(NegativeTestContext & ctx)1705 void unpack_snorm_4x8(NegativeTestContext &ctx)
1706 {
1707 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1708 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1709
1710 ctx.beginSection("unpackSnorm4x8: Invalid v type.");
1711 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1712 {
1713 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1714 {
1715 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1716 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1717 {
1718 if (s_uintTypes[dataTypeNdx] == glu::TYPE_UINT)
1719 continue;
1720
1721 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1722 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_SNORM_4X8, s_uintTypes[dataTypeNdx]));
1723 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1724 }
1725 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1726 {
1727 {
1728 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1729 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_SNORM_4X8, s_intTypes[dataTypeNdx]));
1730 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1731 }
1732 {
1733 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1734 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_SNORM_4X8, s_floatTypes[dataTypeNdx]));
1735 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1736 }
1737 }
1738 ctx.endSection();
1739 }
1740 }
1741 ctx.endSection();
1742 }
1743
unpack_unorm_4x8(NegativeTestContext & ctx)1744 void unpack_unorm_4x8(NegativeTestContext &ctx)
1745 {
1746 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1747 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1748
1749 ctx.beginSection("unpackUnorm4x8: Invalid v type.");
1750 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1751 {
1752 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1753 {
1754 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1755 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_uintTypes); ++dataTypeNdx)
1756 {
1757 if (s_uintTypes[dataTypeNdx] == glu::TYPE_UINT)
1758 continue;
1759
1760 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1761 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_UNORM_4X8, s_uintTypes[dataTypeNdx]));
1762 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1763 }
1764 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_intTypes); ++dataTypeNdx)
1765 {
1766 {
1767 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1768 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_UNORM_4X8, s_intTypes[dataTypeNdx]));
1769 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1770 }
1771 {
1772 const std::string shaderSource(genShaderSourcePackUnpackNorm4x8(
1773 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_UNPACK_UNORM_4X8, s_floatTypes[dataTypeNdx]));
1774 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1775 }
1776 }
1777 ctx.endSection();
1778 }
1779 }
1780 ctx.endSection();
1781 }
1782
1783 // textureSize
genShaderSourceTextureSize_sampler(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType lodDataType)1784 std::string genShaderSourceTextureSize_sampler(NegativeTestContext &ctx, glu::ShaderType shaderType,
1785 glu::DataType samplerDataType, glu::DataType lodDataType)
1786 {
1787 std::ostringstream source;
1788 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1789 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1790 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1791 << "\n"
1792 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
1793 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
1794 << "void main(void)\n"
1795 << "{\n";
1796
1797 switch (samplerDataType)
1798 {
1799 case glu::TYPE_SAMPLER_2D:
1800 case glu::TYPE_INT_SAMPLER_2D:
1801 case glu::TYPE_UINT_SAMPLER_2D:
1802 case glu::TYPE_SAMPLER_3D:
1803 case glu::TYPE_INT_SAMPLER_3D:
1804 case glu::TYPE_UINT_SAMPLER_3D:
1805 case glu::TYPE_SAMPLER_CUBE:
1806 case glu::TYPE_INT_SAMPLER_CUBE:
1807 case glu::TYPE_UINT_SAMPLER_CUBE:
1808 case glu::TYPE_SAMPLER_2D_ARRAY:
1809 case glu::TYPE_INT_SAMPLER_2D_ARRAY:
1810 case glu::TYPE_UINT_SAMPLER_2D_ARRAY:
1811 case glu::TYPE_SAMPLER_CUBE_SHADOW:
1812 case glu::TYPE_SAMPLER_2D_SHADOW:
1813 case glu::TYPE_SAMPLER_2D_ARRAY_SHADOW:
1814 case glu::TYPE_SAMPLER_CUBE_ARRAY:
1815 case glu::TYPE_INT_SAMPLER_CUBE_ARRAY:
1816 case glu::TYPE_UINT_SAMPLER_CUBE_ARRAY:
1817 case glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW:
1818 source << " textureSize(sampler);\n";
1819 break;
1820
1821 case glu::TYPE_SAMPLER_2D_MULTISAMPLE:
1822 case glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE:
1823 case glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE:
1824 case glu::TYPE_SAMPLER_BUFFER:
1825 case glu::TYPE_INT_SAMPLER_BUFFER:
1826 case glu::TYPE_UINT_SAMPLER_BUFFER:
1827 case glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY:
1828 case glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
1829 case glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY:
1830 source << " " << declareAndInitializeShaderVariable(lodDataType, "lod")
1831 << " textureSize(sampler, lod);\n";
1832 break;
1833
1834 default:
1835 DE_FATAL("Unsupported data type.");
1836 }
1837
1838 source << "}\n";
1839
1840 return source.str();
1841 }
1842
checkSupport(NegativeTestContext & ctx)1843 static bool checkSupport(NegativeTestContext &ctx)
1844 {
1845 auto ctxType = ctx.getRenderContext().getType();
1846 return contextSupports(ctxType, glu::ApiType::es(3, 2)) || contextSupports(ctxType, glu::ApiType::core(4, 5));
1847 }
1848
texture_size_invalid_sampler(NegativeTestContext & ctx)1849 void texture_size_invalid_sampler(NegativeTestContext &ctx)
1850 {
1851 ctx.beginSection(
1852 "textureSize: Invalid sampler type - some overloads take two arguments while others take only one.");
1853 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1854 {
1855 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1856 {
1857 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1858 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_samplerTypes); ++dataTypeNdx)
1859 {
1860 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(s_samplerTypes[dataTypeNdx])))
1861 {
1862 ctx.beginSection("Verify sampler data type: " +
1863 std::string(getDataTypeName(s_samplerTypes[dataTypeNdx])));
1864 const std::string shaderSource(genShaderSourceTextureSize_sampler(
1865 ctx, s_shaders[shaderNdx], s_samplerTypes[dataTypeNdx], glu::TYPE_INT));
1866 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1867 ctx.endSection();
1868 }
1869 }
1870 ctx.endSection();
1871 }
1872 }
1873 ctx.endSection();
1874 }
1875
genShaderSourceTextureSize_lod(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType lodDataType)1876 std::string genShaderSourceTextureSize_lod(NegativeTestContext &ctx, glu::ShaderType shaderType,
1877 glu::DataType samplerDataType, glu::DataType lodDataType)
1878 {
1879 std::ostringstream source;
1880 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1881 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1882 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1883 << "\n"
1884 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
1885 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
1886 << "void main(void)\n"
1887 << "{\n"
1888 << " " << declareAndInitializeShaderVariable(lodDataType, "lod") << " textureSize(sampler, lod);\n"
1889 << "}\n";
1890
1891 return source.str();
1892 }
1893
texture_size_invalid_lod(NegativeTestContext & ctx)1894 void texture_size_invalid_lod(NegativeTestContext &ctx)
1895 {
1896 ctx.beginSection("textureSize: Invalid lod type.");
1897 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1898 {
1899 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1900 {
1901 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1902 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_samplerTypes); ++dataTypeNdx)
1903 {
1904 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(s_samplerTypes[dataTypeNdx])))
1905 {
1906 ctx.beginSection("Verify sampler/lod data type" +
1907 std::string(getDataTypeName(s_samplerTypes[dataTypeNdx])));
1908 for (int dataTypeNdx2 = 0; dataTypeNdx2 < DE_LENGTH_OF_ARRAY(s_nonScalarIntTypes); ++dataTypeNdx2)
1909 {
1910 if (s_nonScalarIntTypes[dataTypeNdx2] == glu::TYPE_INT)
1911 continue;
1912
1913 const std::string shaderSource(genShaderSourceTextureSize_lod(
1914 ctx, s_shaders[shaderNdx], s_samplerTypes[dataTypeNdx], s_nonScalarIntTypes[dataTypeNdx2]));
1915 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1916 }
1917 ctx.endSection();
1918 }
1919 }
1920 ctx.endSection();
1921 }
1922 }
1923 ctx.endSection();
1924 }
1925
1926 // texture
genShaderSourceTexture(NegativeTestContext & ctx,glu::ShaderType shaderType,FunctionTextureModes mode,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType thirdArgumentDataType)1927 std::string genShaderSourceTexture(NegativeTestContext &ctx, glu::ShaderType shaderType, FunctionTextureModes mode,
1928 glu::DataType samplerDataType, glu::DataType pDataType,
1929 glu::DataType thirdArgumentDataType)
1930 {
1931 std::ostringstream source;
1932 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
1933 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
1934 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
1935 << "\n"
1936 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
1937 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
1938 << "void main(void)\n"
1939 << "{\n"
1940 << " highp " << declareAndInitializeShaderVariable(pDataType, "lod");
1941
1942 switch (mode)
1943 {
1944 case FUNCTION_TEXTURE_MODE_NO_BIAS_NO_COMPARE:
1945 source << " texture(sampler, lod);\n";
1946 break;
1947
1948 case FUNCTION_TEXTURE_MODE_BIAS_OR_COMPARE:
1949 source << " highp " << declareAndInitializeShaderVariable(thirdArgumentDataType, "thirdArgument")
1950 << " texture(sampler, lod, thirdArgument);\n";
1951 break;
1952
1953 default:
1954 DE_FATAL("Unsupported shader function overload.");
1955 }
1956
1957 source << "}\n";
1958
1959 return source.str();
1960 }
1961
genShaderSourceTexture(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType)1962 std::string genShaderSourceTexture(NegativeTestContext &ctx, glu::ShaderType shaderType, glu::DataType samplerDataType,
1963 glu::DataType pDataType)
1964 {
1965 return genShaderSourceTexture(ctx, shaderType, FUNCTION_TEXTURE_MODE_NO_BIAS_NO_COMPARE, samplerDataType, pDataType,
1966 glu::TYPE_LAST);
1967 }
1968
genShaderSourceTexture(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType thirdArgumentDataType)1969 std::string genShaderSourceTexture(NegativeTestContext &ctx, glu::ShaderType shaderType, glu::DataType samplerDataType,
1970 glu::DataType pDataType, glu::DataType thirdArgumentDataType)
1971 {
1972 return genShaderSourceTexture(ctx, shaderType, FUNCTION_TEXTURE_MODE_BIAS_OR_COMPARE, samplerDataType, pDataType,
1973 thirdArgumentDataType);
1974 }
1975
texture_invalid_p(NegativeTestContext & ctx)1976 void texture_invalid_p(NegativeTestContext &ctx)
1977 {
1978 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
1979 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
1980
1981 ctx.beginSection("texture: Invalid P type.");
1982 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
1983 {
1984 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
1985 {
1986 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
1987 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
1988 {
1989 // SAMPLER_2D
1990 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC2)
1991 {
1992 {
1993 const std::string shaderSource(genShaderSourceTexture(
1994 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, s_floatTypes[dataTypeNdx]));
1995 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
1996 }
1997 {
1998 const std::string shaderSource(
1999 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D,
2000 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2001 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2002 }
2003 {
2004 const std::string shaderSource(genShaderSourceTexture(
2005 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, s_floatTypes[dataTypeNdx]));
2006 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2007 }
2008 {
2009 const std::string shaderSource(
2010 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D,
2011 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2012 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2013 }
2014 {
2015 const std::string shaderSource(genShaderSourceTexture(
2016 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, s_floatTypes[dataTypeNdx]));
2017 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2018 }
2019 {
2020 const std::string shaderSource(
2021 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D,
2022 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2023 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2024 }
2025 }
2026 {
2027 const std::string shaderSource(genShaderSourceTexture(
2028 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, s_intTypes[dataTypeNdx]));
2029 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2030 }
2031 {
2032 const std::string shaderSource(genShaderSourceTexture(
2033 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2034 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2035 }
2036 {
2037 const std::string shaderSource(genShaderSourceTexture(
2038 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, s_intTypes[dataTypeNdx]));
2039 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2040 }
2041 {
2042 const std::string shaderSource(genShaderSourceTexture(
2043 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2044 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2045 }
2046 {
2047 const std::string shaderSource(genShaderSourceTexture(
2048 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, s_intTypes[dataTypeNdx]));
2049 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2050 }
2051 {
2052 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2053 glu::TYPE_UINT_SAMPLER_2D,
2054 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2055 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2056 }
2057 {
2058 const std::string shaderSource(genShaderSourceTexture(
2059 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, s_uintTypes[dataTypeNdx]));
2060 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2061 }
2062 {
2063 const std::string shaderSource(genShaderSourceTexture(
2064 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2065 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2066 }
2067 {
2068 const std::string shaderSource(genShaderSourceTexture(
2069 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, s_uintTypes[dataTypeNdx]));
2070 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2071 }
2072 {
2073 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2074 glu::TYPE_INT_SAMPLER_2D,
2075 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2076 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2077 }
2078 {
2079 const std::string shaderSource(genShaderSourceTexture(
2080 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, s_uintTypes[dataTypeNdx]));
2081 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2082 }
2083 {
2084 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2085 glu::TYPE_UINT_SAMPLER_2D,
2086 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2087 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2088 }
2089
2090 // SAMPLER_3D
2091 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC3)
2092 {
2093 {
2094 const std::string shaderSource(genShaderSourceTexture(
2095 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, s_floatTypes[dataTypeNdx]));
2096 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2097 }
2098 {
2099 const std::string shaderSource(
2100 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D,
2101 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2102 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2103 }
2104 {
2105 const std::string shaderSource(genShaderSourceTexture(
2106 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D, s_floatTypes[dataTypeNdx]));
2107 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2108 }
2109 {
2110 const std::string shaderSource(
2111 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D,
2112 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2113 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2114 }
2115 {
2116 const std::string shaderSource(genShaderSourceTexture(
2117 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, s_floatTypes[dataTypeNdx]));
2118 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2119 }
2120 {
2121 const std::string shaderSource(
2122 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D,
2123 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2124 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2125 }
2126 }
2127 {
2128 const std::string shaderSource(genShaderSourceTexture(
2129 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, s_intTypes[dataTypeNdx]));
2130 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2131 }
2132 {
2133 const std::string shaderSource(genShaderSourceTexture(
2134 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2135 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2136 }
2137 {
2138 const std::string shaderSource(genShaderSourceTexture(
2139 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D, s_intTypes[dataTypeNdx]));
2140 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2141 }
2142 {
2143 const std::string shaderSource(genShaderSourceTexture(
2144 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2145 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2146 }
2147 {
2148 const std::string shaderSource(genShaderSourceTexture(
2149 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, s_intTypes[dataTypeNdx]));
2150 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2151 }
2152 {
2153 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2154 glu::TYPE_UINT_SAMPLER_3D,
2155 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2156 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2157 }
2158 {
2159 const std::string shaderSource(genShaderSourceTexture(
2160 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, s_uintTypes[dataTypeNdx]));
2161 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2162 }
2163 {
2164 const std::string shaderSource(genShaderSourceTexture(
2165 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2166 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2167 }
2168 {
2169 const std::string shaderSource(genShaderSourceTexture(
2170 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D, s_uintTypes[dataTypeNdx]));
2171 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2172 }
2173 {
2174 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2175 glu::TYPE_INT_SAMPLER_3D,
2176 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2177 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2178 }
2179 {
2180 const std::string shaderSource(genShaderSourceTexture(
2181 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, s_uintTypes[dataTypeNdx]));
2182 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2183 }
2184 {
2185 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2186 glu::TYPE_UINT_SAMPLER_3D,
2187 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2188 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2189 }
2190
2191 // SAMPLER_CUBE
2192 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC3)
2193 {
2194 {
2195 const std::string shaderSource(genShaderSourceTexture(
2196 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE, s_floatTypes[dataTypeNdx]));
2197 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2198 }
2199 {
2200 const std::string shaderSource(
2201 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE,
2202 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2203 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2204 }
2205 {
2206 const std::string shaderSource(genShaderSourceTexture(
2207 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, s_floatTypes[dataTypeNdx]));
2208 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2209 }
2210 {
2211 const std::string shaderSource(
2212 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE,
2213 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2214 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2215 }
2216 {
2217 const std::string shaderSource(genShaderSourceTexture(
2218 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, s_floatTypes[dataTypeNdx]));
2219 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2220 }
2221 {
2222 const std::string shaderSource(
2223 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE,
2224 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2225 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2226 }
2227 }
2228 {{const std::string shaderSource(
2229 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE, s_intTypes[dataTypeNdx]));
2230 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2231 }
2232 {
2233 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE,
2234 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2235 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2236 }
2237 {
2238 const std::string shaderSource(genShaderSourceTexture(
2239 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, s_intTypes[dataTypeNdx]));
2240 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2241 }
2242 {
2243 const std::string shaderSource(genShaderSourceTexture(
2244 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2245 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2246 }
2247 {
2248 const std::string shaderSource(genShaderSourceTexture(
2249 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, s_intTypes[dataTypeNdx]));
2250 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2251 }
2252 {
2253 const std::string shaderSource(genShaderSourceTexture(
2254 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2255 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2256 }
2257 }
2258 {
2259 {
2260 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE,
2261 s_uintTypes[dataTypeNdx]));
2262 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2263 }
2264 {
2265 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE,
2266 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2267 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2268 }
2269 {
2270 const std::string shaderSource(genShaderSourceTexture(
2271 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, s_uintTypes[dataTypeNdx]));
2272 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2273 }
2274 {
2275 const std::string shaderSource(genShaderSourceTexture(
2276 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2277 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2278 }
2279 {
2280 const std::string shaderSource(genShaderSourceTexture(
2281 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, s_uintTypes[dataTypeNdx]));
2282 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2283 }
2284 {
2285 const std::string shaderSource(genShaderSourceTexture(
2286 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2287 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2288 }
2289 }
2290
2291 // SAMPLER_2D_ARRAY
2292 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC3)
2293 {
2294 {
2295 const std::string shaderSource(genShaderSourceTexture(
2296 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, s_floatTypes[dataTypeNdx]));
2297 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2298 }
2299 {
2300 const std::string shaderSource(genShaderSourceTexture(
2301 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2302 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2303 }
2304 {
2305 const std::string shaderSource(genShaderSourceTexture(
2306 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, s_floatTypes[dataTypeNdx]));
2307 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2308 }
2309 {
2310 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2311 glu::TYPE_INT_SAMPLER_2D_ARRAY,
2312 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2313 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2314 }
2315 {
2316 const std::string shaderSource(genShaderSourceTexture(
2317 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, s_floatTypes[dataTypeNdx]));
2318 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2319 }
2320 {
2321 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2322 glu::TYPE_UINT_SAMPLER_2D_ARRAY,
2323 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2324 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2325 }
2326 }
2327 {
2328 const std::string shaderSource(
2329 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, s_intTypes[dataTypeNdx]));
2330 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2331 }
2332 {
2333 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2334 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2335 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2336 }
2337 {
2338 const std::string shaderSource(genShaderSourceTexture(
2339 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, s_intTypes[dataTypeNdx]));
2340 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2341 }
2342 {
2343 const std::string shaderSource(genShaderSourceTexture(
2344 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2345 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2346 }
2347 {
2348 const std::string shaderSource(genShaderSourceTexture(
2349 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, s_intTypes[dataTypeNdx]));
2350 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2351 }
2352 {
2353 const std::string shaderSource(genShaderSourceTexture(
2354 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2355 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2356 }
2357 {
2358 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2359 s_uintTypes[dataTypeNdx]));
2360 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2361 }
2362 {
2363 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2364 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2365 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2366 }
2367 {
2368 const std::string shaderSource(genShaderSourceTexture(
2369 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, s_uintTypes[dataTypeNdx]));
2370 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2371 }
2372 {
2373 const std::string shaderSource(genShaderSourceTexture(
2374 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2375 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2376 }
2377 {
2378 const std::string shaderSource(genShaderSourceTexture(
2379 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, s_uintTypes[dataTypeNdx]));
2380 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2381 }
2382 {
2383 const std::string shaderSource(genShaderSourceTexture(
2384 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2385 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2386 }
2387
2388 // SAMPLER_2D_SHADOW
2389 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC3)
2390 {
2391 {
2392 const std::string shaderSource(genShaderSourceTexture(
2393 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, s_floatTypes[dataTypeNdx]));
2394 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2395 }
2396 {
2397 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2398 glu::TYPE_SAMPLER_2D_SHADOW,
2399 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2400 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2401 }
2402 }
2403 {
2404 const std::string shaderSource(genShaderSourceTexture(
2405 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, s_intTypes[dataTypeNdx]));
2406 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2407 }
2408 {
2409 const std::string shaderSource(genShaderSourceTexture(
2410 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2411 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2412 }
2413 {
2414 const std::string shaderSource(genShaderSourceTexture(
2415 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, s_uintTypes[dataTypeNdx]));
2416 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2417 }
2418 {
2419 const std::string shaderSource(genShaderSourceTexture(
2420 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2421 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2422 }
2423
2424 // SAMPLER_CUBE_SHADOW
2425 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC4)
2426 {
2427 {
2428 const std::string shaderSource(genShaderSourceTexture(
2429 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, s_floatTypes[dataTypeNdx]));
2430 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2431 }
2432 {
2433 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2434 glu::TYPE_SAMPLER_CUBE_SHADOW,
2435 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2436 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2437 }
2438 }
2439 {
2440 const std::string shaderSource(genShaderSourceTexture(
2441 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, s_intTypes[dataTypeNdx]));
2442 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2443 }
2444 {
2445 const std::string shaderSource(genShaderSourceTexture(
2446 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2447 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2448 }
2449 {
2450 const std::string shaderSource(genShaderSourceTexture(
2451 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, s_uintTypes[dataTypeNdx]));
2452 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2453 }
2454 {
2455 const std::string shaderSource(genShaderSourceTexture(
2456 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2457 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2458 }
2459
2460 // SAMPLER_2D_ARRAY_SHADOW
2461 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC4)
2462 {
2463 {
2464 const std::string shaderSource(genShaderSourceTexture(
2465 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, s_floatTypes[dataTypeNdx]));
2466 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2467 }
2468 {
2469 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2470 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
2471 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2472 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2473 }
2474 }
2475 {
2476 const std::string shaderSource(genShaderSourceTexture(
2477 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, s_intTypes[dataTypeNdx]));
2478 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2479 }
2480 {
2481 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2482 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
2483 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2484 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2485 }
2486 {
2487 const std::string shaderSource(genShaderSourceTexture(
2488 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, s_uintTypes[dataTypeNdx]));
2489 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2490 }
2491 {
2492 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2493 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
2494 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2495 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2496 }
2497
2498 // SAMPLER_CUBE_ARRAY
2499 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
2500 {
2501 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC4)
2502 {
2503 {
2504 const std::string shaderSource(genShaderSourceTexture(
2505 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, s_floatTypes[dataTypeNdx]));
2506 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2507 }
2508 {
2509 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2510 glu::TYPE_SAMPLER_CUBE_ARRAY,
2511 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2512 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2513 }
2514 {
2515 const std::string shaderSource(genShaderSourceTexture(
2516 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY, s_floatTypes[dataTypeNdx]));
2517 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2518 }
2519 {
2520 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2521 glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2522 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2523 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2524 }
2525 {
2526 const std::string shaderSource(genShaderSourceTexture(
2527 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY, s_floatTypes[dataTypeNdx]));
2528 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2529 }
2530 {
2531 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2532 glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2533 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2534 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2535 }
2536 }
2537 {
2538 const std::string shaderSource(genShaderSourceTexture(
2539 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, s_intTypes[dataTypeNdx]));
2540 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2541 }
2542 {
2543 const std::string shaderSource(genShaderSourceTexture(
2544 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2545 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2546 }
2547 {
2548 const std::string shaderSource(genShaderSourceTexture(
2549 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY, s_intTypes[dataTypeNdx]));
2550 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2551 }
2552 {
2553 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2554 glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2555 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2556 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2557 }
2558 {
2559 const std::string shaderSource(genShaderSourceTexture(
2560 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY, s_intTypes[dataTypeNdx]));
2561 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2562 }
2563 {
2564 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2565 glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2566 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2567 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2568 }
2569 {
2570 const std::string shaderSource(genShaderSourceTexture(
2571 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, s_uintTypes[dataTypeNdx]));
2572 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2573 }
2574 {
2575 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2576 glu::TYPE_SAMPLER_CUBE_ARRAY,
2577 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2578 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2579 }
2580 {
2581 const std::string shaderSource(genShaderSourceTexture(
2582 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY, s_uintTypes[dataTypeNdx]));
2583 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2584 }
2585 {
2586 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2587 glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2588 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2589 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2590 }
2591 {
2592 const std::string shaderSource(genShaderSourceTexture(
2593 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY, s_uintTypes[dataTypeNdx]));
2594 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2595 }
2596 {
2597 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2598 glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2599 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2600 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2601 }
2602 }
2603
2604 // SAMPLER_CUBE_ARRAY_SHADOW
2605 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW)))
2606 {
2607 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC4)
2608 {
2609 std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2610 glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
2611 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
2612 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2613 }
2614 {
2615 std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2616 glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
2617 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
2618 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2619 }
2620 {
2621 std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2622 glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
2623 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
2624 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2625 }
2626 }
2627 }
2628 ctx.endSection();
2629 }
2630 } // namespace
2631 ctx.endSection();
2632 } // namespace NegativeTestShared
2633
texture_invalid_bias_or_compare(NegativeTestContext & ctx)2634 void texture_invalid_bias_or_compare(NegativeTestContext &ctx)
2635 {
2636 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
2637 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
2638
2639 ctx.beginSection("texture: Invalid bias/compare type.");
2640 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
2641 {
2642 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
2643 {
2644 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
2645 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
2646 {
2647 // SAMPLER_2D
2648 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2649 {
2650 {
2651 const std::string shaderSource(
2652 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D,
2653 glu::TYPE_FLOAT_VEC2, s_floatTypes[dataTypeNdx]));
2654 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2655 }
2656 {
2657 const std::string shaderSource(
2658 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D,
2659 glu::TYPE_FLOAT_VEC2, s_floatTypes[dataTypeNdx]));
2660 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2661 }
2662 {
2663 const std::string shaderSource(
2664 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D,
2665 glu::TYPE_FLOAT_VEC2, s_floatTypes[dataTypeNdx]));
2666 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2667 }
2668 }
2669 {
2670 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2671 glu::TYPE_SAMPLER_2D, glu::TYPE_FLOAT_VEC2,
2672 s_intTypes[dataTypeNdx]));
2673 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2674 }
2675 {
2676 const std::string shaderSource(
2677 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D,
2678 glu::TYPE_FLOAT_VEC2, s_uintTypes[dataTypeNdx]));
2679 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2680 }
2681 {
2682 const std::string shaderSource(
2683 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D,
2684 glu::TYPE_FLOAT_VEC2, s_intTypes[dataTypeNdx]));
2685 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2686 }
2687 {
2688 const std::string shaderSource(
2689 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D,
2690 glu::TYPE_FLOAT_VEC2, s_uintTypes[dataTypeNdx]));
2691 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2692 }
2693 {
2694 const std::string shaderSource(
2695 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D,
2696 glu::TYPE_FLOAT_VEC2, s_intTypes[dataTypeNdx]));
2697 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2698 }
2699 {
2700 const std::string shaderSource(
2701 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D,
2702 glu::TYPE_FLOAT_VEC2, s_uintTypes[dataTypeNdx]));
2703 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2704 }
2705
2706 // SAMPLER_3D
2707 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2708 {
2709 {
2710 const std::string shaderSource(
2711 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D,
2712 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2713 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2714 }
2715 {
2716 const std::string shaderSource(
2717 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D,
2718 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2719 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2720 }
2721 {
2722 const std::string shaderSource(
2723 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D,
2724 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2725 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2726 }
2727 }
2728 {
2729 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2730 glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC3,
2731 s_intTypes[dataTypeNdx]));
2732 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2733 }
2734 {
2735 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2736 glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC3,
2737 s_uintTypes[dataTypeNdx]));
2738 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2739 }
2740 {
2741 const std::string shaderSource(
2742 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D,
2743 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2744 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2745 }
2746 {
2747 const std::string shaderSource(
2748 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_3D,
2749 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2750 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2751 }
2752 {
2753 const std::string shaderSource(
2754 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D,
2755 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2756 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2757 }
2758 {
2759 const std::string shaderSource(
2760 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D,
2761 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2762 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2763 }
2764
2765 // SAMPLER_CUBE
2766 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2767 {
2768 std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE,
2769 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2770 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2771 shaderSource = genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE,
2772 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]);
2773 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2774 shaderSource = genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE,
2775 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]);
2776 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2777 }
2778 {
2779 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2780 glu::TYPE_SAMPLER_CUBE, glu::TYPE_FLOAT_VEC3,
2781 s_intTypes[dataTypeNdx]));
2782 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2783 }
2784 {
2785 const std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2786 glu::TYPE_SAMPLER_CUBE, glu::TYPE_FLOAT_VEC3,
2787 s_uintTypes[dataTypeNdx]));
2788 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2789 }
2790 {
2791 const std::string shaderSource(
2792 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE,
2793 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2794 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2795 }
2796 {
2797 const std::string shaderSource(
2798 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE,
2799 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2800 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2801 }
2802 {
2803 const std::string shaderSource(
2804 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE,
2805 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2806 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2807 }
2808 {
2809 const std::string shaderSource(
2810 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE,
2811 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2812 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2813 }
2814
2815 // SAMPLER_2D_ARRAY
2816 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2817 {
2818 {
2819 const std::string shaderSource(
2820 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2821 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2822 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2823 }
2824 {
2825 const std::string shaderSource(
2826 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY,
2827 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2828 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2829 }
2830 {
2831 const std::string shaderSource(
2832 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY,
2833 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2834 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2835 }
2836 }
2837 {
2838 const std::string shaderSource(
2839 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2840 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2841 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2842 }
2843 {
2844 const std::string shaderSource(
2845 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY,
2846 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2847 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2848 }
2849 {
2850 const std::string shaderSource(
2851 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY,
2852 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2853 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2854 }
2855 {
2856 const std::string shaderSource(
2857 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY,
2858 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2859 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2860 }
2861 {
2862 const std::string shaderSource(
2863 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY,
2864 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2865 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2866 }
2867 {
2868 const std::string shaderSource(
2869 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY,
2870 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2871 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2872 }
2873
2874 // SAMPLER_2D_SHADOW
2875 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2876 {
2877 const std::string shaderSource(
2878 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW,
2879 glu::TYPE_FLOAT_VEC3, s_floatTypes[dataTypeNdx]));
2880 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2881 }
2882 {
2883 const std::string shaderSource(
2884 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW,
2885 glu::TYPE_FLOAT_VEC3, s_intTypes[dataTypeNdx]));
2886 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2887 }
2888 {
2889 const std::string shaderSource(
2890 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW,
2891 glu::TYPE_FLOAT_VEC3, s_uintTypes[dataTypeNdx]));
2892 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2893 }
2894
2895 // SAMPLER_CUBE_SHADOW
2896 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2897 {
2898 std::string shaderSource(genShaderSourceTexture(ctx, s_shaders[shaderNdx],
2899 glu::TYPE_SAMPLER_CUBE_SHADOW, glu::TYPE_FLOAT_VEC4,
2900 s_floatTypes[dataTypeNdx]));
2901 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2902 }
2903 {
2904 const std::string shaderSource(
2905 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW,
2906 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
2907 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2908 }
2909 {
2910 const std::string shaderSource(
2911 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW,
2912 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
2913 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2914 }
2915
2916 // SAMPLER_CUBE_ARRAY
2917 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
2918 {
2919 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2920 {
2921 {
2922 const std::string shaderSource(
2923 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
2924 glu::TYPE_FLOAT_VEC4, s_floatTypes[dataTypeNdx]));
2925 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2926 }
2927 {
2928 const std::string shaderSource(
2929 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2930 glu::TYPE_FLOAT_VEC4, s_floatTypes[dataTypeNdx]));
2931 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2932 }
2933 {
2934 const std::string shaderSource(
2935 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2936 glu::TYPE_FLOAT_VEC4, s_floatTypes[dataTypeNdx]));
2937 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2938 }
2939 }
2940 {
2941 const std::string shaderSource(
2942 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
2943 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
2944 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2945 }
2946 {
2947 const std::string shaderSource(
2948 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
2949 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
2950 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2951 }
2952 {
2953 const std::string shaderSource(
2954 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2955 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
2956 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2957 }
2958 {
2959 const std::string shaderSource(
2960 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
2961 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
2962 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2963 }
2964 {
2965 const std::string shaderSource(
2966 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2967 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
2968 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2969 }
2970 {
2971 const std::string shaderSource(
2972 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
2973 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
2974 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2975 }
2976 }
2977
2978 // SAMPLER_CUBE_ARRAY_SHADOW
2979 if (checkSupport(ctx) ||
2980 ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW)))
2981 {
2982 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
2983 {
2984 {
2985 const std::string shaderSource(
2986 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
2987 glu::TYPE_FLOAT_VEC4, s_floatTypes[dataTypeNdx]));
2988 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2989 }
2990 }
2991 {
2992 const std::string shaderSource(
2993 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
2994 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
2995 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
2996 }
2997 {
2998 const std::string shaderSource(
2999 genShaderSourceTexture(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
3000 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
3001 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3002 }
3003 }
3004 }
3005 ctx.endSection();
3006 }
3007 }
3008 ctx.endSection();
3009 }
3010
3011 // textureLod
genShaderSourceTextureLod(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType lodDataType)3012 std::string genShaderSourceTextureLod(NegativeTestContext &ctx, glu::ShaderType shaderType,
3013 glu::DataType samplerDataType, glu::DataType pDataType, glu::DataType lodDataType)
3014 {
3015 std::ostringstream source;
3016 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
3017 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
3018 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
3019 << "\n"
3020 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
3021 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
3022 << "void main(void)\n"
3023 << "{\n"
3024 << " " << declareAndInitializeShaderVariable(pDataType, "P") << " "
3025 << declareAndInitializeShaderVariable(lodDataType, "lod") << " textureLod(sampler, P, lod);\n"
3026 << "}\n";
3027
3028 return source.str();
3029 }
3030
texture_lod_invalid_p(NegativeTestContext & ctx)3031 void texture_lod_invalid_p(NegativeTestContext &ctx)
3032 {
3033 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
3034 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
3035
3036 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
3037 {
3038 ctx.beginSection("textureLod: Invalid P type.");
3039 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3040 {
3041 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3042 {
3043 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3044 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
3045 {
3046 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT_VEC4)
3047 {
3048 {
3049 const std::string shaderSource(
3050 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3051 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
3052 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3053 }
3054 {
3055 const std::string shaderSource(
3056 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3057 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
3058 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3059 }
3060 {
3061 const std::string shaderSource(
3062 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3063 s_floatTypes[dataTypeNdx], glu::TYPE_FLOAT));
3064 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3065 }
3066 }
3067 {
3068 const std::string shaderSource(
3069 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3070 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
3071 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3072 }
3073 {
3074 const std::string shaderSource(
3075 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3076 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
3077 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3078 }
3079 {
3080 const std::string shaderSource(
3081 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3082 s_intTypes[dataTypeNdx], glu::TYPE_FLOAT));
3083 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3084 }
3085 {
3086 const std::string shaderSource(
3087 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3088 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
3089 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3090 }
3091 {
3092 const std::string shaderSource(
3093 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3094 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
3095 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3096 }
3097 {
3098 const std::string shaderSource(
3099 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3100 s_uintTypes[dataTypeNdx], glu::TYPE_FLOAT));
3101 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3102 }
3103 }
3104 ctx.endSection();
3105 }
3106 }
3107 ctx.endSection();
3108 }
3109 }
3110
texture_lod_invalid_lod(NegativeTestContext & ctx)3111 void texture_lod_invalid_lod(NegativeTestContext &ctx)
3112 {
3113 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
3114 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
3115
3116 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
3117 {
3118 ctx.beginSection("textureLod: Invalid lod type.");
3119 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3120 {
3121 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3122 {
3123 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3124 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
3125 {
3126 if (s_floatTypes[dataTypeNdx] != glu::TYPE_FLOAT)
3127 {
3128 {
3129 const std::string shaderSource(
3130 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3131 glu::TYPE_FLOAT, s_floatTypes[dataTypeNdx]));
3132 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3133 }
3134 {
3135 const std::string shaderSource(
3136 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3137 glu::TYPE_FLOAT, s_floatTypes[dataTypeNdx]));
3138 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3139 }
3140 {
3141 const std::string shaderSource(
3142 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3143 glu::TYPE_FLOAT, s_floatTypes[dataTypeNdx]));
3144 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3145 }
3146 }
3147 {
3148 const std::string shaderSource(
3149 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3150 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
3151 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3152 }
3153 {
3154 const std::string shaderSource(
3155 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3156 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
3157 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3158 }
3159 {
3160 const std::string shaderSource(
3161 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3162 glu::TYPE_FLOAT_VEC4, s_intTypes[dataTypeNdx]));
3163 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3164 }
3165 {
3166 const std::string shaderSource(
3167 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3168 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
3169 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3170 }
3171 {
3172 const std::string shaderSource(
3173 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3174 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
3175 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3176 }
3177 {
3178 const std::string shaderSource(
3179 genShaderSourceTextureLod(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3180 glu::TYPE_FLOAT_VEC4, s_uintTypes[dataTypeNdx]));
3181 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3182 }
3183 }
3184 ctx.endSection();
3185 }
3186 }
3187 ctx.endSection();
3188 }
3189 }
3190
3191 // texelFetch
genShaderSourceTexelFetch(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType sampleDataType)3192 std::string genShaderSourceTexelFetch(NegativeTestContext &ctx, glu::ShaderType shaderType,
3193 glu::DataType samplerDataType, glu::DataType pDataType,
3194 glu::DataType sampleDataType)
3195 {
3196 std::ostringstream source;
3197 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
3198 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
3199 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
3200 << "\n"
3201 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
3202 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
3203 << "void main(void)\n"
3204 << "{\n"
3205 << " " << declareAndInitializeShaderVariable(pDataType, "P");
3206
3207 switch (samplerDataType)
3208 {
3209 case glu::TYPE_SAMPLER_2D_MULTISAMPLE:
3210 case glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE:
3211 case glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE:
3212 case glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY:
3213 case glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
3214 case glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY:
3215 source << " " << declareAndInitializeShaderVariable(sampleDataType, "varSample")
3216 << " texelFetch(sampler, P, varSample);\n";
3217 break;
3218
3219 case glu::TYPE_SAMPLER_BUFFER:
3220 case glu::TYPE_INT_SAMPLER_BUFFER:
3221 case glu::TYPE_UINT_SAMPLER_BUFFER:
3222 source << " texelFetch(sampler, P);\n";
3223 break;
3224
3225 default:
3226 DE_FATAL("Unsupported data type.");
3227 }
3228
3229 source << "}\n";
3230
3231 return source.str();
3232 }
3233
genShaderSourceTexelFetch(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType)3234 std::string genShaderSourceTexelFetch(NegativeTestContext &ctx, glu::ShaderType shaderType,
3235 glu::DataType samplerDataType, glu::DataType pDataType)
3236 {
3237 return genShaderSourceTexelFetch(ctx, shaderType, samplerDataType, pDataType, glu::TYPE_LAST);
3238 }
3239
texel_fetch_invalid_p(NegativeTestContext & ctx)3240 void texel_fetch_invalid_p(NegativeTestContext &ctx)
3241 {
3242 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
3243 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
3244
3245 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
3246 {
3247 ctx.beginSection("texelFetch: Invalid P type.");
3248 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3249 {
3250 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3251 {
3252 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3253 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
3254 {
3255 // SAMPLER_2D_MULTISAMPLE
3256 {
3257 const std::string shaderSource(
3258 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3259 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3260 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3261 }
3262 {
3263 const std::string shaderSource(
3264 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
3265 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3266 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3267 }
3268 {
3269 const std::string shaderSource(
3270 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
3271 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3272 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3273 }
3274
3275 if (s_intTypes[dataTypeNdx] != glu::TYPE_INT_VEC2)
3276 {
3277 {
3278 const std::string shaderSource(
3279 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3280 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3281 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3282 }
3283 {
3284 const std::string shaderSource(genShaderSourceTexelFetch(
3285 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
3286 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3287 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3288 }
3289 {
3290 const std::string shaderSource(genShaderSourceTexelFetch(
3291 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
3292 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3293 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3294 }
3295 }
3296 {
3297 const std::string shaderSource(
3298 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3299 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3300 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3301 }
3302 {
3303 const std::string shaderSource(
3304 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
3305 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3306 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3307 }
3308 {
3309 const std::string shaderSource(
3310 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
3311 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3312 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3313 }
3314
3315 // SAMPLER_BUFFER
3316 {
3317 const std::string shaderSource(genShaderSourceTexelFetch(
3318 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_BUFFER, s_floatTypes[dataTypeNdx]));
3319 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3320 }
3321 {
3322 const std::string shaderSource(genShaderSourceTexelFetch(
3323 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_BUFFER, s_floatTypes[dataTypeNdx]));
3324 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3325 }
3326 {
3327 const std::string shaderSource(genShaderSourceTexelFetch(
3328 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_BUFFER, s_floatTypes[dataTypeNdx]));
3329 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3330 }
3331
3332 if (s_intTypes[dataTypeNdx] != glu::TYPE_INT)
3333 {
3334 {
3335 const std::string shaderSource(genShaderSourceTexelFetch(
3336 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_BUFFER, s_intTypes[dataTypeNdx]));
3337 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3338 }
3339 {
3340 const std::string shaderSource(genShaderSourceTexelFetch(
3341 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_BUFFER, s_intTypes[dataTypeNdx]));
3342 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3343 }
3344 {
3345 const std::string shaderSource(genShaderSourceTexelFetch(
3346 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_BUFFER, s_intTypes[dataTypeNdx]));
3347 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3348 }
3349 }
3350
3351 {
3352 const std::string shaderSource(genShaderSourceTexelFetch(
3353 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_BUFFER, s_uintTypes[dataTypeNdx]));
3354 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3355 }
3356 {
3357 const std::string shaderSource(genShaderSourceTexelFetch(
3358 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_BUFFER, s_uintTypes[dataTypeNdx]));
3359 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3360 }
3361 {
3362 const std::string shaderSource(genShaderSourceTexelFetch(
3363 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_BUFFER, s_uintTypes[dataTypeNdx]));
3364 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3365 }
3366
3367 // SAMPLER_2D_MULTISAMPLE_ARRAY
3368 {
3369 const std::string shaderSource(
3370 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
3371 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3372 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3373 }
3374 {
3375 const std::string shaderSource(genShaderSourceTexelFetch(
3376 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3377 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3378 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3379 }
3380 {
3381 const std::string shaderSource(genShaderSourceTexelFetch(
3382 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3383 s_floatTypes[dataTypeNdx], glu::TYPE_INT));
3384 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3385 }
3386
3387 if (s_intTypes[dataTypeNdx] != glu::TYPE_INT_VEC3)
3388 {
3389 {
3390 const std::string shaderSource(genShaderSourceTexelFetch(
3391 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
3392 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3393 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3394 }
3395 {
3396 const std::string shaderSource(genShaderSourceTexelFetch(
3397 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3398 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3399 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3400 }
3401 {
3402 const std::string shaderSource(genShaderSourceTexelFetch(
3403 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3404 s_intTypes[dataTypeNdx], glu::TYPE_INT));
3405 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3406 }
3407 }
3408 {
3409 const std::string shaderSource(
3410 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
3411 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3412 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3413 }
3414 {
3415 const std::string shaderSource(genShaderSourceTexelFetch(
3416 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3417 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3418 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3419 }
3420 {
3421 const std::string shaderSource(genShaderSourceTexelFetch(
3422 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3423 s_uintTypes[dataTypeNdx], glu::TYPE_INT));
3424 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3425 }
3426 }
3427 ctx.endSection();
3428 }
3429 }
3430 ctx.endSection();
3431 }
3432 }
3433
texel_fetch_invalid_sample(NegativeTestContext & ctx)3434 void texel_fetch_invalid_sample(NegativeTestContext &ctx)
3435 {
3436 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_intTypes));
3437 DE_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == DE_LENGTH_OF_ARRAY(s_uintTypes));
3438
3439 if (checkSupport(ctx) || ctx.isExtensionSupported(getDataTypeExtension(glu::TYPE_SAMPLER_CUBE_ARRAY)))
3440 {
3441 ctx.beginSection("texelFetch: Invalid sample type.");
3442 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3443 {
3444 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3445 {
3446 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3447 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_floatTypes); ++dataTypeNdx)
3448 {
3449 // SAMPLER_2D_MULTISAMPLE
3450 {
3451 const std::string shaderSource(
3452 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3453 glu::TYPE_INT_VEC2, s_floatTypes[dataTypeNdx]));
3454 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3455 }
3456 {
3457 const std::string shaderSource(
3458 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
3459 glu::TYPE_INT_VEC2, s_floatTypes[dataTypeNdx]));
3460 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3461 }
3462 {
3463 const std::string shaderSource(
3464 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
3465 glu::TYPE_INT_VEC2, s_floatTypes[dataTypeNdx]));
3466 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3467 }
3468
3469 // SAMPLER_2D_MULTISAMPLE_ARRAY
3470 {
3471 const std::string shaderSource(
3472 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
3473 glu::TYPE_INT_VEC3, s_floatTypes[dataTypeNdx]));
3474 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3475 }
3476 {
3477 const std::string shaderSource(genShaderSourceTexelFetch(
3478 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, glu::TYPE_INT_VEC3,
3479 s_floatTypes[dataTypeNdx]));
3480 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3481 }
3482 {
3483 const std::string shaderSource(genShaderSourceTexelFetch(
3484 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, glu::TYPE_INT_VEC3,
3485 s_floatTypes[dataTypeNdx]));
3486 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3487 }
3488
3489 if (s_intTypes[dataTypeNdx] != glu::TYPE_INT)
3490 {
3491 // SAMPLER_2D_MULTISAMPLE
3492 {
3493 const std::string shaderSource(
3494 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3495 glu::TYPE_INT_VEC2, s_intTypes[dataTypeNdx]));
3496 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3497 }
3498 {
3499 const std::string shaderSource(genShaderSourceTexelFetch(
3500 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE, glu::TYPE_INT_VEC2,
3501 s_intTypes[dataTypeNdx]));
3502 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3503 }
3504 {
3505 const std::string shaderSource(genShaderSourceTexelFetch(
3506 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE, glu::TYPE_INT_VEC2,
3507 s_intTypes[dataTypeNdx]));
3508 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3509 }
3510
3511 // SAMPLER_2D_MULTISAMPLE_ARRAY
3512 {
3513 const std::string shaderSource(genShaderSourceTexelFetch(
3514 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY, glu::TYPE_INT_VEC3,
3515 s_intTypes[dataTypeNdx]));
3516 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3517 }
3518 {
3519 const std::string shaderSource(genShaderSourceTexelFetch(
3520 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3521 glu::TYPE_INT_VEC3, s_intTypes[dataTypeNdx]));
3522 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3523 }
3524 {
3525 const std::string shaderSource(genShaderSourceTexelFetch(
3526 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
3527 glu::TYPE_INT_VEC3, s_intTypes[dataTypeNdx]));
3528 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3529 }
3530 }
3531
3532 // SAMPLER_2D_MULTISAMPLE
3533 {
3534 const std::string shaderSource(
3535 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE,
3536 glu::TYPE_INT_VEC2, s_uintTypes[dataTypeNdx]));
3537 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3538 }
3539 {
3540 const std::string shaderSource(
3541 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
3542 glu::TYPE_INT_VEC2, s_uintTypes[dataTypeNdx]));
3543 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3544 }
3545 {
3546 const std::string shaderSource(
3547 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
3548 glu::TYPE_INT_VEC2, s_uintTypes[dataTypeNdx]));
3549 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3550 }
3551
3552 // SAMPLER_2D_MULTISAMPLE_ARRAY
3553 {
3554 const std::string shaderSource(
3555 genShaderSourceTexelFetch(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
3556 glu::TYPE_INT_VEC3, s_uintTypes[dataTypeNdx]));
3557 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3558 }
3559 {
3560 const std::string shaderSource(genShaderSourceTexelFetch(
3561 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, glu::TYPE_INT_VEC3,
3562 s_uintTypes[dataTypeNdx]));
3563 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3564 }
3565 {
3566 const std::string shaderSource(genShaderSourceTexelFetch(
3567 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, glu::TYPE_INT_VEC3,
3568 s_uintTypes[dataTypeNdx]));
3569 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3570 }
3571 }
3572 ctx.endSection();
3573 }
3574 }
3575 ctx.endSection();
3576 }
3577 }
3578
3579 // EmitVertex, EndPrimitive
genShaderSourceGeometry(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function)3580 std::string genShaderSourceGeometry(NegativeTestContext &ctx, glu::ShaderType shaderType, ShaderFunction function)
3581 {
3582 DE_ASSERT(function == SHADER_FUNCTION_EMIT_VERTEX || function == SHADER_FUNCTION_END_PRIMITIVE);
3583
3584 std::ostringstream source;
3585 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
3586 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
3587 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
3588 << "\n"
3589 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
3590 << "{\n";
3591
3592 switch (function)
3593 {
3594 case SHADER_FUNCTION_EMIT_VERTEX:
3595 source << " EmitVertex();\n";
3596 break;
3597
3598 case SHADER_FUNCTION_END_PRIMITIVE:
3599 source << " EndPrimitive();\n";
3600 break;
3601
3602 default:
3603 DE_FATAL("Unsupported shader function.");
3604 }
3605
3606 source << "}\n";
3607
3608 return source.str();
3609 }
3610
emit_vertex(NegativeTestContext & ctx)3611 void emit_vertex(NegativeTestContext &ctx)
3612 {
3613 ctx.beginSection("EmitVertex.");
3614 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3615 {
3616 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3617 {
3618 if (s_shaders[shaderNdx] == glu::SHADERTYPE_GEOMETRY)
3619 continue;
3620
3621 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3622 const std::string shaderSource =
3623 genShaderSourceGeometry(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_EMIT_VERTEX);
3624 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3625 ctx.endSection();
3626 }
3627 }
3628 ctx.endSection();
3629 }
3630
end_primitive(NegativeTestContext & ctx)3631 void end_primitive(NegativeTestContext &ctx)
3632 {
3633 ctx.beginSection("EndPrimitieve.");
3634 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3635 {
3636 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3637 {
3638 if (s_shaders[shaderNdx] == glu::SHADERTYPE_GEOMETRY)
3639 continue;
3640
3641 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3642 const std::string shaderSource =
3643 genShaderSourceGeometry(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_END_PRIMITIVE);
3644 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3645 ctx.endSection();
3646 }
3647 }
3648 ctx.endSection();
3649 }
3650
3651 // textureGrad
genShaderSourceTextureGrad(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType dpdxDataType,glu::DataType dpdyDataType)3652 std::string genShaderSourceTextureGrad(NegativeTestContext &ctx, glu::ShaderType shaderType,
3653 glu::DataType samplerDataType, glu::DataType pDataType,
3654 glu::DataType dpdxDataType, glu::DataType dpdyDataType)
3655 {
3656 std::ostringstream source;
3657
3658 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
3659 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
3660 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
3661 << "\n"
3662 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
3663 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
3664 << "void main(void)\n"
3665 << "{\n"
3666 << " mediump " << declareAndInitializeShaderVariable(pDataType, "P") << " mediump "
3667 << declareAndInitializeShaderVariable(dpdxDataType, "dPdx") << " mediump "
3668 << declareAndInitializeShaderVariable(dpdyDataType, "dPdy") << " textureGrad(sampler, P, dPdx, dPdy);\n"
3669 << "}\n";
3670
3671 return source.str();
3672 }
3673
texture_grad(NegativeTestContext & ctx)3674 void texture_grad(NegativeTestContext &ctx)
3675 {
3676 TCU_CHECK_AND_THROW(NotSupportedError,
3677 ctx.isExtensionSupported("GL_EXT_texture_cube_map_array") || checkSupport(ctx),
3678 "Test requires support for GL_EXT_texture_cube_map_array or version 3.2.");
3679
3680 ctx.beginSection("textureGrad.");
3681 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3682 {
3683 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3684 {
3685 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3686 {
3687 const std::string shaderSource(genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx],
3688 glu::TYPE_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT,
3689 glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT_VEC3));
3690 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3691 }
3692 {
3693 const std::string shaderSource(
3694 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3695 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC3));
3696 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3697 }
3698 {
3699 const std::string shaderSource(
3700 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY,
3701 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3702 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3703 }
3704 {
3705 const std::string shaderSource(
3706 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3707 glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT_VEC3));
3708 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3709 }
3710 {
3711 const std::string shaderSource(
3712 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3713 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC3));
3714 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3715 }
3716 {
3717 const std::string shaderSource(
3718 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
3719 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3720 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3721 }
3722 {
3723 const std::string shaderSource(
3724 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3725 glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT_VEC3));
3726 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3727 }
3728 {
3729 const std::string shaderSource(
3730 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3731 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC3));
3732 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3733 }
3734 {
3735 const std::string shaderSource(
3736 genShaderSourceTextureGrad(ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
3737 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3738 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3739 }
3740 ctx.endSection();
3741 }
3742 }
3743 ctx.endSection();
3744 }
3745
3746 // textureGather
genShaderSourceTextureGather(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType thirdArgument)3747 std::string genShaderSourceTextureGather(NegativeTestContext &ctx, glu::ShaderType shaderType,
3748 glu::DataType samplerDataType, glu::DataType pDataType,
3749 glu::DataType thirdArgument)
3750 {
3751 std::ostringstream source;
3752
3753 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
3754 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
3755 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
3756 << "\n"
3757 << getShaderExtensionDeclaration(getDataTypeExtension(samplerDataType))
3758 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
3759 << "void main(void)\n"
3760 << "{\n"
3761 << " mediump " << declareAndInitializeShaderVariable(pDataType, "P");
3762
3763 if (thirdArgument != glu::TYPE_LAST)
3764 source << " mediump " << declareAndInitializeShaderVariable(thirdArgument, "arg3")
3765 << " textureGather(sampler, P, arg3);\n";
3766 else
3767 source << " textureGather(sampler, P);\n";
3768
3769 source << "}\n";
3770
3771 return source.str();
3772 }
3773
genShaderSourceTextureGather(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType samplerDataType,glu::DataType pDataType)3774 std::string genShaderSourceTextureGather(NegativeTestContext &ctx, glu::ShaderType shaderType,
3775 glu::DataType samplerDataType, glu::DataType pDataType)
3776 {
3777 return genShaderSourceTextureGather(ctx, shaderType, samplerDataType, pDataType, glu::TYPE_LAST);
3778 }
3779
texture_gather_sampler_2d(NegativeTestContext & ctx)3780 void texture_gather_sampler_2d(NegativeTestContext &ctx)
3781 {
3782 ctx.beginSection("textureGrad - sampler2D");
3783 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3784 {
3785 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3786 {
3787 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3788 {
3789 const std::string shaderSource(
3790 genShaderSourceTextureGather(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, glu::TYPE_FLOAT));
3791 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3792 }
3793 {
3794 const std::string shaderSource(genShaderSourceTextureGather(
3795 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
3796 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3797 }
3798 {
3799 const std::string shaderSource(genShaderSourceTextureGather(
3800 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D, glu::TYPE_FLOAT, glu::TYPE_INT));
3801 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3802 }
3803 {
3804 const std::string shaderSource(
3805 genShaderSourceTextureGather(ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, glu::TYPE_FLOAT));
3806 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3807 }
3808 {
3809 const std::string shaderSource(genShaderSourceTextureGather(
3810 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
3811 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3812 }
3813 {
3814 const std::string shaderSource(genShaderSourceTextureGather(
3815 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D, glu::TYPE_FLOAT, glu::TYPE_INT));
3816 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3817 }
3818 {
3819 const std::string shaderSource(genShaderSourceTextureGather(
3820 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, glu::TYPE_FLOAT));
3821 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3822 }
3823 {
3824 const std::string shaderSource(genShaderSourceTextureGather(
3825 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
3826 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3827 }
3828 {
3829 const std::string shaderSource(genShaderSourceTextureGather(
3830 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D, glu::TYPE_FLOAT, glu::TYPE_INT));
3831 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3832 }
3833 {
3834 const std::string shaderSource(genShaderSourceTextureGather(
3835 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC2));
3836 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3837 }
3838 {
3839 const std::string shaderSource(genShaderSourceTextureGather(
3840 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
3841 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3842 }
3843 ctx.endSection();
3844 }
3845 }
3846 ctx.endSection();
3847 }
3848
texture_gather_sampler_2d_array(NegativeTestContext & ctx)3849 void texture_gather_sampler_2d_array(NegativeTestContext &ctx)
3850 {
3851 ctx.beginSection("textureGrad - sampler2DArray");
3852 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3853 {
3854 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3855 {
3856 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3857 {
3858 const std::string shaderSource(genShaderSourceTextureGather(
3859 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT));
3860 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3861 }
3862 {
3863 const std::string shaderSource(genShaderSourceTextureGather(
3864 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3865 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3866 }
3867 {
3868 const std::string shaderSource(genShaderSourceTextureGather(
3869 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
3870 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3871 }
3872 {
3873 const std::string shaderSource(genShaderSourceTextureGather(
3874 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT));
3875 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3876 }
3877 {
3878 const std::string shaderSource(genShaderSourceTextureGather(
3879 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3880 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3881 }
3882 {
3883 const std::string shaderSource(genShaderSourceTextureGather(
3884 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
3885 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3886 }
3887 {
3888 const std::string shaderSource(genShaderSourceTextureGather(
3889 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT));
3890 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3891 }
3892 {
3893 const std::string shaderSource(genShaderSourceTextureGather(
3894 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3895 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3896 }
3897 {
3898 const std::string shaderSource(genShaderSourceTextureGather(
3899 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
3900 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3901 }
3902 {
3903 const std::string shaderSource(genShaderSourceTextureGather(
3904 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC3));
3905 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3906 }
3907 {
3908 const std::string shaderSource(genShaderSourceTextureGather(
3909 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
3910 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3911 }
3912 ctx.endSection();
3913 }
3914 }
3915 ctx.endSection();
3916 }
3917
texture_gather_sampler_cube(NegativeTestContext & ctx)3918 void texture_gather_sampler_cube(NegativeTestContext &ctx)
3919 {
3920 ctx.beginSection("textureGrad - samplerCube");
3921 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3922 {
3923 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3924 {
3925 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3926 {
3927 const std::string shaderSource(
3928 genShaderSourceTextureGather(ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE, glu::TYPE_FLOAT));
3929 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3930 }
3931 {
3932 const std::string shaderSource(genShaderSourceTextureGather(
3933 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3934 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3935 }
3936 {
3937 const std::string shaderSource(genShaderSourceTextureGather(
3938 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE, glu::TYPE_FLOAT, glu::TYPE_INT));
3939 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3940 }
3941 {
3942 const std::string shaderSource(genShaderSourceTextureGather(
3943 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, glu::TYPE_FLOAT));
3944 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3945 }
3946 {
3947 const std::string shaderSource(genShaderSourceTextureGather(
3948 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3949 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3950 }
3951 {
3952 const std::string shaderSource(genShaderSourceTextureGather(
3953 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE, glu::TYPE_FLOAT, glu::TYPE_INT));
3954 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3955 }
3956 {
3957 const std::string shaderSource(genShaderSourceTextureGather(
3958 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, glu::TYPE_FLOAT));
3959 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3960 }
3961 {
3962 const std::string shaderSource(genShaderSourceTextureGather(
3963 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
3964 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3965 }
3966 {
3967 const std::string shaderSource(genShaderSourceTextureGather(
3968 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE, glu::TYPE_FLOAT, glu::TYPE_INT));
3969 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3970 }
3971 {
3972 const std::string shaderSource(genShaderSourceTextureGather(
3973 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC3));
3974 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3975 }
3976 {
3977 const std::string shaderSource(genShaderSourceTextureGather(
3978 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_3D, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
3979 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3980 }
3981 ctx.endSection();
3982 }
3983 }
3984 ctx.endSection();
3985 }
3986
texture_gather_sampler_2d_shadow(NegativeTestContext & ctx)3987 void texture_gather_sampler_2d_shadow(NegativeTestContext &ctx)
3988 {
3989 ctx.beginSection("textureGrad - sampler2DShadow");
3990 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
3991 {
3992 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
3993 {
3994 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
3995 {
3996 const std::string shaderSource(genShaderSourceTextureGather(
3997 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, glu::TYPE_FLOAT));
3998 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
3999 }
4000 {
4001 const std::string shaderSource(genShaderSourceTextureGather(
4002 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
4003 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4004 }
4005 {
4006 const std::string shaderSource(genShaderSourceTextureGather(
4007 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_SHADOW, glu::TYPE_FLOAT, glu::TYPE_FLOAT));
4008 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4009 }
4010 {
4011 const std::string shaderSource(genShaderSourceTextureGather(
4012 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
4013 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4014 }
4015 ctx.endSection();
4016 }
4017 }
4018 ctx.endSection();
4019 }
4020
texture_gather_sampler_2d_array_shadow(NegativeTestContext & ctx)4021 void texture_gather_sampler_2d_array_shadow(NegativeTestContext &ctx)
4022 {
4023 ctx.beginSection("textureGrad - sampler2DArrayShadow");
4024 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4025 {
4026 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4027 {
4028 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4029 {
4030 const std::string shaderSource(genShaderSourceTextureGather(
4031 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT));
4032 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4033 }
4034 {
4035 const std::string shaderSource(genShaderSourceTextureGather(
4036 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4037 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4038 }
4039 {
4040 const std::string shaderSource(genShaderSourceTextureGather(
4041 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT, glu::TYPE_FLOAT));
4042 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4043 }
4044 {
4045 const std::string shaderSource(genShaderSourceTextureGather(
4046 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
4047 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4048 }
4049 ctx.endSection();
4050 }
4051 }
4052 ctx.endSection();
4053 }
4054
texture_gather_sampler_cube_shadow(NegativeTestContext & ctx)4055 void texture_gather_sampler_cube_shadow(NegativeTestContext &ctx)
4056 {
4057 ctx.beginSection("textureGrad - samplerCubeShadow");
4058 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4059 {
4060 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4061 {
4062 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4063 {
4064 const std::string shaderSource(genShaderSourceTextureGather(
4065 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, glu::TYPE_FLOAT));
4066 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4067 }
4068 {
4069 const std::string shaderSource(genShaderSourceTextureGather(
4070 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4071 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4072 }
4073 {
4074 const std::string shaderSource(genShaderSourceTextureGather(
4075 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_SHADOW, glu::TYPE_FLOAT, glu::TYPE_FLOAT));
4076 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4077 }
4078 {
4079 const std::string shaderSource(genShaderSourceTextureGather(
4080 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
4081 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4082 }
4083 ctx.endSection();
4084 }
4085 }
4086 ctx.endSection();
4087 }
4088
texture_gather_sampler_cube_array(NegativeTestContext & ctx)4089 void texture_gather_sampler_cube_array(NegativeTestContext &ctx)
4090 {
4091 TCU_CHECK_AND_THROW(NotSupportedError,
4092 checkSupport(ctx) || ctx.isExtensionSupported("GL_EXT_texture_cube_map_array"),
4093 "Test requires extension GL_EXT_texture_cube_map_array or context version 3.2 or higher.");
4094
4095 ctx.beginSection("textureGrad - samplerCubeArray");
4096 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4097 {
4098 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4099 {
4100 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4101 {
4102 const std::string shaderSource(genShaderSourceTextureGather(
4103 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT));
4104 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4105 }
4106 {
4107 const std::string shaderSource(genShaderSourceTextureGather(
4108 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
4109 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4110 }
4111 {
4112 const std::string shaderSource(genShaderSourceTextureGather(
4113 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
4114 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4115 }
4116 {
4117 const std::string shaderSource(genShaderSourceTextureGather(
4118 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT));
4119 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4120 }
4121 {
4122 const std::string shaderSource(genShaderSourceTextureGather(
4123 ctx, s_shaders[shaderNdx], glu::TYPE_INT_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
4124 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4125 }
4126 {
4127 const std::string shaderSource(genShaderSourceTextureGather(ctx, s_shaders[shaderNdx],
4128 glu::TYPE_INT_SAMPLER_CUBE_ARRAY,
4129 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
4130 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4131 }
4132 {
4133 const std::string shaderSource(genShaderSourceTextureGather(
4134 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT));
4135 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4136 }
4137 {
4138 const std::string shaderSource(genShaderSourceTextureGather(
4139 ctx, s_shaders[shaderNdx], glu::TYPE_UINT_SAMPLER_CUBE_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT));
4140 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4141 }
4142 {
4143 const std::string shaderSource(genShaderSourceTextureGather(ctx, s_shaders[shaderNdx],
4144 glu::TYPE_UINT_SAMPLER_CUBE_ARRAY,
4145 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
4146 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4147 }
4148 {
4149 const std::string shaderSource(genShaderSourceTextureGather(
4150 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC4, glu::TYPE_INT));
4151 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4152 }
4153 ctx.endSection();
4154 }
4155 }
4156 ctx.endSection();
4157 }
4158
texture_gather_sampler_cube_array_shadow(NegativeTestContext & ctx)4159 void texture_gather_sampler_cube_array_shadow(NegativeTestContext &ctx)
4160 {
4161 TCU_CHECK_AND_THROW(NotSupportedError,
4162 checkSupport(ctx) || ctx.isExtensionSupported("GL_EXT_texture_cube_map_array"),
4163 "Test requires extension GL_EXT_texture_cube_map_array or context version 3.2 or higher.");
4164
4165 ctx.beginSection("textureGrad - samplerCubeArrayShadow");
4166 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4167 {
4168 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4169 {
4170 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4171 {
4172 const std::string shaderSource(genShaderSourceTextureGather(
4173 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW, glu::TYPE_FLOAT));
4174 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4175 }
4176 {
4177 const std::string shaderSource(genShaderSourceTextureGather(
4178 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW, glu::TYPE_FLOAT, glu::TYPE_FLOAT));
4179 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4180 }
4181 {
4182 const std::string shaderSource(genShaderSourceTextureGather(ctx, s_shaders[shaderNdx],
4183 glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
4184 glu::TYPE_FLOAT_VEC4, glu::TYPE_INT));
4185 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4186 }
4187 {
4188 const std::string shaderSource(genShaderSourceTextureGather(
4189 ctx, s_shaders[shaderNdx], glu::TYPE_SAMPLER_3D, glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
4190 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4191 }
4192 ctx.endSection();
4193 }
4194 }
4195 ctx.endSection();
4196 }
4197
4198 // textureGatherOffset
genShaderSourceTextureGatherOffset(NegativeTestContext & ctx,glu::ShaderType shaderType,FunctionTextureGatherOffsetModes mode,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType offsetDataType,glu::DataType fourthArgument)4199 std::string genShaderSourceTextureGatherOffset(NegativeTestContext &ctx, glu::ShaderType shaderType,
4200 FunctionTextureGatherOffsetModes mode, glu::DataType samplerDataType,
4201 glu::DataType pDataType, glu::DataType offsetDataType,
4202 glu::DataType fourthArgument)
4203 {
4204 DE_ASSERT(mode < FUNCTION_TEXTURE_GATHER_OFFSET_MODE_LAST);
4205
4206 std::ostringstream source;
4207
4208 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
4209 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
4210 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
4211 << "\n"
4212 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(samplerDataType, "sampler")
4213 << "void main(void)\n"
4214 << "{\n"
4215 << " mediump " << declareAndInitializeShaderVariable(pDataType, "P") << " mediump "
4216 << declareAndInitializeShaderVariable(offsetDataType, "offset");
4217
4218 switch (mode)
4219 {
4220 case FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP:
4221 {
4222 if (fourthArgument != glu::TYPE_LAST)
4223 source << " mediump " << declareAndInitializeShaderVariable(fourthArgument, "comp")
4224 << " textureGatherOffset(sampler, P, offset, comp);\n";
4225 else
4226 source << " textureGatherOffset(sampler, P, offset);\n";
4227 break;
4228 }
4229
4230 case FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z:
4231 {
4232 source << " mediump " << declareAndInitializeShaderVariable(fourthArgument, "refZ")
4233 << " textureGatherOffset(sampler, P, refZ, offset);\n";
4234 break;
4235 }
4236
4237 default:
4238 DE_FATAL("Unsupported shader function overload.");
4239 }
4240
4241 source << "}\n";
4242
4243 return source.str();
4244 }
4245
genShaderSourceTextureGatherOffset(NegativeTestContext & ctx,glu::ShaderType shaderType,FunctionTextureGatherOffsetModes mode,glu::DataType samplerDataType,glu::DataType pDataType,glu::DataType offsetDataType)4246 std::string genShaderSourceTextureGatherOffset(NegativeTestContext &ctx, glu::ShaderType shaderType,
4247 FunctionTextureGatherOffsetModes mode, glu::DataType samplerDataType,
4248 glu::DataType pDataType, glu::DataType offsetDataType)
4249 {
4250 DE_ASSERT(mode == FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP);
4251
4252 return genShaderSourceTextureGatherOffset(ctx, shaderType, mode, samplerDataType, pDataType, offsetDataType,
4253 glu::TYPE_LAST);
4254 }
4255
texture_gather_offset_sampler_2d(NegativeTestContext & ctx)4256 void texture_gather_offset_sampler_2d(NegativeTestContext &ctx)
4257 {
4258 ctx.beginSection("textureGatherOffset - sampler2D");
4259 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4260 {
4261 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4262 {
4263 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4264 {
4265 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4266 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D,
4267 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4268 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4269 }
4270 {
4271 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4272 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D,
4273 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
4274 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4275 }
4276 {
4277 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4278 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D,
4279 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4280 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4281 }
4282 {
4283 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4284 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D,
4285 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT, glu::TYPE_INT));
4286 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4287 }
4288 {
4289 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4290 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D,
4291 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4292 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4293 }
4294 {
4295 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4296 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D,
4297 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4298 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4299 }
4300 {
4301 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4302 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D,
4303 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
4304 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4305 }
4306 {
4307 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4308 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D,
4309 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4310 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4311 }
4312 {
4313 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4314 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D,
4315 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT, glu::TYPE_INT));
4316 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4317 }
4318 {
4319 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4320 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D,
4321 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4322 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4323 }
4324 {
4325 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4326 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_2D,
4327 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4328 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4329 }
4330 {
4331 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4332 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_2D,
4333 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
4334 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4335 }
4336 {
4337 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4338 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_2D,
4339 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4340 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4341 }
4342 {
4343 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4344 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_2D,
4345 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT, glu::TYPE_INT));
4346 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4347 }
4348 {
4349 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4350 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_2D,
4351 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4352 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4353 }
4354 {
4355 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4356 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_3D,
4357 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2));
4358 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4359 }
4360 {
4361 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4362 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_3D,
4363 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4364 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4365 }
4366 ctx.endSection();
4367 }
4368 }
4369 ctx.endSection();
4370 }
4371
texture_gather_offset_sampler_2d_array(NegativeTestContext & ctx)4372 void texture_gather_offset_sampler_2d_array(NegativeTestContext &ctx)
4373 {
4374 ctx.beginSection("textureGatherOffset - sampler2DArray");
4375 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4376 {
4377 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4378 {
4379 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4380 {
4381 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4382 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D_ARRAY,
4383 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4384 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4385 }
4386 {
4387 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4388 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D_ARRAY,
4389 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4390 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4391 }
4392 {
4393 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4394 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D_ARRAY,
4395 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4396 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4397 }
4398 {
4399 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4400 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D_ARRAY,
4401 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_INT));
4402 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4403 }
4404 {
4405 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4406 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_SAMPLER_2D_ARRAY,
4407 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_FLOAT));
4408 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4409 }
4410 {
4411 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4412 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D_ARRAY,
4413 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4414 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4415 }
4416 {
4417 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4418 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D_ARRAY,
4419 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4420 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4421 }
4422 {
4423 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4424 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D_ARRAY,
4425 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4426 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4427 }
4428 {
4429 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4430 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D_ARRAY,
4431 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_INT));
4432 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4433 }
4434 {
4435 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4436 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_INT_SAMPLER_2D_ARRAY,
4437 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_FLOAT));
4438 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4439 }
4440 {
4441 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4442 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
4443 glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT_VEC2));
4444 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4445 }
4446 {
4447 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4448 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
4449 glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4450 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4451 }
4452 {
4453 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4454 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
4455 glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4456 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4457 }
4458 {
4459 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4460 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
4461 glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_INT));
4462 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4463 }
4464 {
4465 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4466 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
4467 glu::TYPE_UINT_SAMPLER_2D_ARRAY, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_FLOAT));
4468 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4469 }
4470 {
4471 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4472 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP, glu::TYPE_UINT_SAMPLER_3D,
4473 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4474 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4475 }
4476 ctx.endSection();
4477 }
4478 }
4479 ctx.endSection();
4480 }
4481
texture_gather_offset_sampler_2d_shadow(NegativeTestContext & ctx)4482 void texture_gather_offset_sampler_2d_shadow(NegativeTestContext &ctx)
4483 {
4484 ctx.beginSection("textureGatherOffset - sampler2DShadow");
4485 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4486 {
4487 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4488 {
4489 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4490 {
4491 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4492 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z, glu::TYPE_SAMPLER_2D_SHADOW,
4493 glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4494 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4495 }
4496 {
4497 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4498 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z, glu::TYPE_SAMPLER_2D_SHADOW,
4499 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4500 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4501 }
4502 {
4503 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4504 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z, glu::TYPE_SAMPLER_2D_SHADOW,
4505 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT, glu::TYPE_FLOAT));
4506 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4507 }
4508 {
4509 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4510 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z, glu::TYPE_SAMPLER_3D,
4511 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4512 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4513 }
4514 ctx.endSection();
4515 }
4516 }
4517 ctx.endSection();
4518 }
4519
texture_gather_offset_sampler_2d_array_shadow(NegativeTestContext & ctx)4520 void texture_gather_offset_sampler_2d_array_shadow(NegativeTestContext &ctx)
4521 {
4522 ctx.beginSection("textureGatherOffset - sampler2DShadow");
4523 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4524 {
4525 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4526 {
4527 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4528 {
4529 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4530 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
4531 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4532 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4533 }
4534 {
4535 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4536 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
4537 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT_VEC2, glu::TYPE_INT));
4538 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4539 }
4540 {
4541 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4542 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
4543 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, glu::TYPE_FLOAT_VEC3, glu::TYPE_INT, glu::TYPE_FLOAT));
4544 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4545 }
4546 {
4547 const std::string shaderSource(genShaderSourceTextureGatherOffset(
4548 ctx, s_shaders[shaderNdx], FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z, glu::TYPE_SAMPLER_3D,
4549 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT_VEC2, glu::TYPE_FLOAT));
4550 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4551 }
4552 ctx.endSection();
4553 }
4554 }
4555 ctx.endSection();
4556 }
4557
4558 // atomicAdd, atomicMin, atomicMax, atomicAnd, atomicOr, atomixXor, atomixExchange, atomicCompSwap
genShaderSourceAtomicOperations(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType memDataType,glu::DataType dataDataType,glu::DataType compareDataType)4559 std::string genShaderSourceAtomicOperations(NegativeTestContext &ctx, glu::ShaderType shaderType,
4560 ShaderFunction function, glu::DataType memDataType,
4561 glu::DataType dataDataType, glu::DataType compareDataType)
4562 {
4563 DE_ASSERT(SHADER_FUNCTION_ATOMIC_ADD <= function && function <= SHADER_FUNCTION_ATOMIC_COMP_SWAP);
4564
4565 std::ostringstream source;
4566
4567 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
4568 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
4569 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
4570 << "\n"
4571 << getShaderInitialization(ctx, shaderType) << declareBuffer(memDataType, "mem") << "void main()\n"
4572 << "{\n"
4573 << " mediump " << declareAndInitializeShaderVariable(dataDataType, "data");
4574
4575 switch (function)
4576 {
4577 case SHADER_FUNCTION_ATOMIC_ADD:
4578 source << " atomicAdd(mem, data);\n";
4579 break;
4580 case SHADER_FUNCTION_ATOMIC_MIN:
4581 source << " atomicMin(mem, data);\n";
4582 break;
4583 case SHADER_FUNCTION_ATOMIC_MAX:
4584 source << " atomicMax(mem, data);\n";
4585 break;
4586 case SHADER_FUNCTION_ATOMIC_AND:
4587 source << " atomicAnd(mem, data);\n";
4588 break;
4589 case SHADER_FUNCTION_ATOMIC_OR:
4590 source << " atomicOr(mem, data);\n";
4591 break;
4592 case SHADER_FUNCTION_ATOMIC_XOR:
4593 source << " atomicXor(mem, data);\n";
4594 break;
4595 case SHADER_FUNCTION_ATOMIC_EXCHANGE:
4596 source << " atomicExchange(mem, data);\n";
4597 break;
4598 case SHADER_FUNCTION_ATOMIC_COMP_SWAP:
4599 source << " mediump " << declareAndInitializeShaderVariable(compareDataType, "compare")
4600 << " atomicCompSwap(mem, compare, data);\n";
4601 break;
4602
4603 default:
4604 DE_FATAL("Unsupported shader function.");
4605 }
4606
4607 source << "}\n";
4608
4609 return source.str();
4610 }
4611
genShaderSourceAtomicOperations(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType memDataType,glu::DataType dataDataType)4612 std::string genShaderSourceAtomicOperations(NegativeTestContext &ctx, glu::ShaderType shaderType,
4613 ShaderFunction function, glu::DataType memDataType,
4614 glu::DataType dataDataType)
4615 {
4616 DE_ASSERT(function != SHADER_FUNCTION_ATOMIC_COMP_SWAP);
4617
4618 return genShaderSourceAtomicOperations(ctx, shaderType, function, memDataType, dataDataType, glu::TYPE_LAST);
4619 }
4620
atomic_add(NegativeTestContext & ctx)4621 void atomic_add(NegativeTestContext &ctx)
4622 {
4623 ctx.beginSection("atomicAdd");
4624 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4625 {
4626 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4627 {
4628 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4629 {
4630 const std::string shaderSource(genShaderSourceAtomicOperations(
4631 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_ADD, glu::TYPE_UINT, glu::TYPE_INT));
4632 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4633 }
4634 {
4635 const std::string shaderSource(genShaderSourceAtomicOperations(
4636 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_ADD, glu::TYPE_INT, glu::TYPE_UINT));
4637 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4638 }
4639 ctx.endSection();
4640 }
4641 }
4642 ctx.endSection();
4643 }
4644
atomic_min(NegativeTestContext & ctx)4645 void atomic_min(NegativeTestContext &ctx)
4646 {
4647 ctx.beginSection("atomicMin");
4648 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4649 {
4650 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4651 {
4652 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4653 {
4654 const std::string shaderSource(genShaderSourceAtomicOperations(
4655 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_MIN, glu::TYPE_UINT, glu::TYPE_INT));
4656 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4657 }
4658 {
4659 const std::string shaderSource(genShaderSourceAtomicOperations(
4660 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_MIN, glu::TYPE_INT, glu::TYPE_UINT));
4661 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4662 }
4663 ctx.endSection();
4664 }
4665 }
4666 ctx.endSection();
4667 }
4668
atomic_max(NegativeTestContext & ctx)4669 void atomic_max(NegativeTestContext &ctx)
4670 {
4671 ctx.beginSection("atomicMax");
4672 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4673 {
4674 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4675 {
4676 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4677 {
4678 const std::string shaderSource(genShaderSourceAtomicOperations(
4679 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_MAX, glu::TYPE_UINT, glu::TYPE_INT));
4680 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4681 }
4682 {
4683 const std::string shaderSource(genShaderSourceAtomicOperations(
4684 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_MAX, glu::TYPE_INT, glu::TYPE_UINT));
4685 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4686 }
4687 ctx.endSection();
4688 }
4689 }
4690 ctx.endSection();
4691 }
4692
atomic_and(NegativeTestContext & ctx)4693 void atomic_and(NegativeTestContext &ctx)
4694 {
4695 ctx.beginSection("atomicAnd");
4696 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4697 {
4698 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4699 {
4700 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4701 {
4702 const std::string shaderSource(genShaderSourceAtomicOperations(
4703 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_AND, glu::TYPE_UINT, glu::TYPE_INT));
4704 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4705 }
4706 {
4707 const std::string shaderSource(genShaderSourceAtomicOperations(
4708 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_AND, glu::TYPE_INT, glu::TYPE_UINT));
4709 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4710 }
4711 ctx.endSection();
4712 }
4713 }
4714 ctx.endSection();
4715 }
4716
atomic_or(NegativeTestContext & ctx)4717 void atomic_or(NegativeTestContext &ctx)
4718 {
4719 ctx.beginSection("atomicOr");
4720 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4721 {
4722 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4723 {
4724 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4725 {
4726 const std::string shaderSource(genShaderSourceAtomicOperations(
4727 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_OR, glu::TYPE_UINT, glu::TYPE_INT));
4728 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4729 }
4730 {
4731 const std::string shaderSource(genShaderSourceAtomicOperations(
4732 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_OR, glu::TYPE_INT, glu::TYPE_UINT));
4733 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4734 }
4735 ctx.endSection();
4736 }
4737 }
4738 ctx.endSection();
4739 }
4740
atomic_xor(NegativeTestContext & ctx)4741 void atomic_xor(NegativeTestContext &ctx)
4742 {
4743 ctx.beginSection("atomicXor");
4744 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4745 {
4746 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4747 {
4748 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4749 {
4750 const std::string shaderSource(genShaderSourceAtomicOperations(
4751 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_XOR, glu::TYPE_UINT, glu::TYPE_INT));
4752 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4753 }
4754 {
4755 const std::string shaderSource(genShaderSourceAtomicOperations(
4756 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_XOR, glu::TYPE_INT, glu::TYPE_UINT));
4757 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4758 }
4759 ctx.endSection();
4760 }
4761 }
4762 ctx.endSection();
4763 }
4764
atomic_exchange(NegativeTestContext & ctx)4765 void atomic_exchange(NegativeTestContext &ctx)
4766 {
4767 ctx.beginSection("atomicExchange");
4768 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4769 {
4770 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4771 {
4772 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4773 {
4774 const std::string shaderSource(genShaderSourceAtomicOperations(
4775 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_EXCHANGE, glu::TYPE_UINT, glu::TYPE_INT));
4776 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4777 }
4778 {
4779 const std::string shaderSource(genShaderSourceAtomicOperations(
4780 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_EXCHANGE, glu::TYPE_INT, glu::TYPE_UINT));
4781 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4782 }
4783 ctx.endSection();
4784 }
4785 }
4786 ctx.endSection();
4787 }
4788
atomic_comp_swap(NegativeTestContext & ctx)4789 void atomic_comp_swap(NegativeTestContext &ctx)
4790 {
4791 ctx.beginSection("atomicCompSwap");
4792 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4793 {
4794 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4795 {
4796 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4797 {
4798 const std::string shaderSource(
4799 genShaderSourceAtomicOperations(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_COMP_SWAP,
4800 glu::TYPE_UINT, glu::TYPE_INT, glu::TYPE_INT));
4801 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4802 }
4803 {
4804 const std::string shaderSource(
4805 genShaderSourceAtomicOperations(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_COMP_SWAP,
4806 glu::TYPE_INT, glu::TYPE_UINT, glu::TYPE_INT));
4807 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4808 }
4809 {
4810 const std::string shaderSource(
4811 genShaderSourceAtomicOperations(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_ATOMIC_COMP_SWAP,
4812 glu::TYPE_INT, glu::TYPE_INT, glu::TYPE_UINT));
4813 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4814 }
4815 ctx.endSection();
4816 }
4817 }
4818 ctx.endSection();
4819 }
4820
4821 // interpolatedAtCentroid, interpolatedAtSample, interpolateAtOffset,
genShaderSourceInterpolateAt(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType interpolantDataType,glu::DataType secondArgumentDataType)4822 std::string genShaderSourceInterpolateAt(NegativeTestContext &ctx, glu::ShaderType shaderType, ShaderFunction function,
4823 glu::DataType interpolantDataType, glu::DataType secondArgumentDataType)
4824 {
4825 DE_ASSERT(function >= SHADER_FUNCTION_INTERPOLATED_AT_CENTROID &&
4826 function <= SHADER_FUNCTION_INTERPOLATED_AT_OFFSET);
4827
4828 auto ctxType = ctx.getRenderContext().getType();
4829 const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
4830 glu::contextSupports(ctxType, glu::ApiType::core(4, 5));
4831
4832 std::ostringstream source;
4833 source << (isES32orGL45 ? glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
4834 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
4835 << "\n"
4836 << getShaderInitialization(ctx, shaderType)
4837 << (isES32orGL45 ? "" : getShaderExtensionDeclaration("GL_OES_shader_multisample_interpolation"))
4838 << declareShaderInput(interpolantDataType, "interpolant") << "void main()\n"
4839 << "{\n";
4840
4841 switch (function)
4842 {
4843 case SHADER_FUNCTION_INTERPOLATED_AT_CENTROID:
4844 source << " interpolateAtCentroid(interpolant);\n";
4845 break;
4846
4847 case SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE:
4848 source << " mediump " << declareAndInitializeShaderVariable(secondArgumentDataType, "sample")
4849 << " interpolateAtSample(interpolant, sample);\n";
4850 break;
4851
4852 case SHADER_FUNCTION_INTERPOLATED_AT_OFFSET:
4853 source << " mediump " << declareAndInitializeShaderVariable(secondArgumentDataType, "offset")
4854 << " interpolateAtOffset(interpolant, offset);\n";
4855 break;
4856
4857 default:
4858 DE_FATAL("Unsupported shader function.");
4859 }
4860
4861 source << "}\n";
4862
4863 return source.str();
4864 }
4865
genShaderSourceInterpolateAt(NegativeTestContext & ctx,glu::ShaderType shaderType,ShaderFunction function,glu::DataType interpolantDataType)4866 std::string genShaderSourceInterpolateAt(NegativeTestContext &ctx, glu::ShaderType shaderType, ShaderFunction function,
4867 glu::DataType interpolantDataType)
4868 {
4869 DE_ASSERT(function == SHADER_FUNCTION_INTERPOLATED_AT_CENTROID);
4870
4871 return genShaderSourceInterpolateAt(ctx, shaderType, function, interpolantDataType, glu::TYPE_LAST);
4872 }
4873
interpolate_at_centroid(NegativeTestContext & ctx)4874 void interpolate_at_centroid(NegativeTestContext &ctx)
4875 {
4876 TCU_CHECK_AND_THROW(NotSupportedError,
4877 checkSupport(ctx) || ctx.isExtensionSupported("GL_OES_shader_multisample_interpolation"),
4878 "This test requires a context version 3.2 or higher.");
4879
4880 ctx.beginSection("interpolateAtCentroid");
4881 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4882 {
4883 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4884 {
4885 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4886 if (s_shaders[shaderNdx] == glu::SHADERTYPE_FRAGMENT)
4887 {
4888 const std::string shaderSource(genShaderSourceInterpolateAt(
4889 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_CENTROID, glu::TYPE_INT));
4890 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4891 }
4892 else
4893 {
4894 {
4895 const std::string shaderSource(genShaderSourceInterpolateAt(
4896 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_CENTROID, glu::TYPE_FLOAT));
4897 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4898 }
4899 {
4900 const std::string shaderSource(genShaderSourceInterpolateAt(
4901 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_CENTROID, glu::TYPE_FLOAT_VEC2));
4902 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4903 }
4904 {
4905 const std::string shaderSource(genShaderSourceInterpolateAt(
4906 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_CENTROID, glu::TYPE_FLOAT_VEC3));
4907 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4908 }
4909 {
4910 const std::string shaderSource(genShaderSourceInterpolateAt(
4911 ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_CENTROID, glu::TYPE_FLOAT_VEC4));
4912 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4913 }
4914 }
4915 ctx.endSection();
4916 }
4917 }
4918 ctx.endSection();
4919 }
4920
interpolate_at_sample(NegativeTestContext & ctx)4921 void interpolate_at_sample(NegativeTestContext &ctx)
4922 {
4923 TCU_CHECK_AND_THROW(NotSupportedError,
4924 checkSupport(ctx) || ctx.isExtensionSupported("GL_OES_shader_multisample_interpolation"),
4925 "This test requires a context version 3.2 or higher.");
4926
4927 ctx.beginSection("interpolateAtSample");
4928 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
4929 {
4930 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
4931 {
4932 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
4933 if (s_shaders[shaderNdx] == glu::SHADERTYPE_FRAGMENT)
4934 {
4935 {
4936 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4937 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4938 glu::TYPE_INT, glu::TYPE_INT));
4939 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4940 }
4941 {
4942 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4943 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4944 glu::TYPE_FLOAT, glu::TYPE_FLOAT));
4945 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4946 }
4947 {
4948 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4949 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4950 glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
4951 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4952 }
4953 {
4954 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4955 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4956 glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
4957 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4958 }
4959 {
4960 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4961 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4962 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
4963 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4964 }
4965 }
4966 else
4967 {
4968 {
4969 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4970 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4971 glu::TYPE_FLOAT, glu::TYPE_INT));
4972 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4973 }
4974 {
4975 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4976 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4977 glu::TYPE_FLOAT_VEC2, glu::TYPE_INT));
4978 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4979 }
4980 {
4981 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4982 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4983 glu::TYPE_FLOAT_VEC3, glu::TYPE_INT));
4984 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4985 }
4986 {
4987 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
4988 SHADER_FUNCTION_INTERPOLATED_AT_SAMPLE,
4989 glu::TYPE_FLOAT_VEC4, glu::TYPE_INT));
4990 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
4991 }
4992 }
4993 ctx.endSection();
4994 }
4995 }
4996 ctx.endSection();
4997 }
4998
interpolate_at_offset(NegativeTestContext & ctx)4999 void interpolate_at_offset(NegativeTestContext &ctx)
5000 {
5001 TCU_CHECK_AND_THROW(NotSupportedError,
5002 checkSupport(ctx) || ctx.isExtensionSupported("GL_OES_shader_multisample_interpolation"),
5003 "This test requires a context version 3.2 or higher.");
5004
5005 ctx.beginSection("interpolateAtOffset");
5006 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
5007 {
5008 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
5009 {
5010 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
5011 if (s_shaders[shaderNdx] == glu::SHADERTYPE_FRAGMENT)
5012 {
5013 {
5014 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5015 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5016 glu::TYPE_INT, glu::TYPE_FLOAT_VEC2));
5017 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5018 }
5019 {
5020 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5021 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5022 glu::TYPE_FLOAT, glu::TYPE_FLOAT));
5023 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5024 }
5025 {
5026 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5027 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5028 glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT));
5029 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5030 }
5031 {
5032 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5033 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5034 glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT));
5035 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5036 }
5037 {
5038 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5039 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5040 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT));
5041 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5042 }
5043 }
5044 else
5045 {
5046 {
5047 const std::string shaderSource(genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx],
5048 SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5049 glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC2));
5050 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5051 }
5052 {
5053 const std::string shaderSource(
5054 genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5055 glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT_VEC2));
5056 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5057 }
5058 {
5059 const std::string shaderSource(
5060 genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5061 glu::TYPE_FLOAT_VEC3, glu::TYPE_FLOAT_VEC2));
5062 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5063 }
5064 {
5065 const std::string shaderSource(
5066 genShaderSourceInterpolateAt(ctx, s_shaders[shaderNdx], SHADER_FUNCTION_INTERPOLATED_AT_OFFSET,
5067 glu::TYPE_FLOAT_VEC4, glu::TYPE_FLOAT_VEC2));
5068 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5069 }
5070 }
5071 ctx.endSection();
5072 }
5073 }
5074 ctx.endSection();
5075 }
5076
5077 // textureGatherOffsets
genShaderSourceTextureGatherOffsets(NegativeTestContext & ctx,glu::ShaderType shaderType,const TextureGatherOffsetsTestSpec & spec)5078 std::string genShaderSourceTextureGatherOffsets(NegativeTestContext &ctx, glu::ShaderType shaderType,
5079 const TextureGatherOffsetsTestSpec &spec)
5080 {
5081 std::ostringstream source;
5082
5083 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
5084 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
5085 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
5086 << "\n"
5087 << getShaderInitialization(ctx, shaderType) << declareShaderUniform(spec.samplerDataType, "sampler")
5088 << "void main(void)\n"
5089 << "{\n"
5090 << " mediump " << declareAndInitializeShaderVariable(spec.pDataType, "P") << " mediump "
5091 << (spec.offsetIsConst ? "const " : "")
5092 << declareShaderArrayVariable(spec.offsetsDataType, "offsets", spec.offsetArraySize) << "\n";
5093
5094 switch (spec.mode)
5095 {
5096 case FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP:
5097 {
5098 if (spec.fourthArgument != glu::TYPE_LAST)
5099 source << " mediump " << declareAndInitializeShaderVariable(spec.fourthArgument, "comp")
5100 << " textureGatherOffsets(sampler, P, offsets, comp);\n";
5101 else
5102 source << " textureGatherOffsets(sampler, P, offsets);\n";
5103 break;
5104 }
5105
5106 case FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z:
5107 {
5108 source << " mediump " << declareAndInitializeShaderVariable(spec.fourthArgument, "refZ")
5109 << " textureGatherOffsets(sampler, P, refZ, offsets);\n";
5110 break;
5111 }
5112
5113 default:
5114 DE_FATAL("Unsupported shader function overload.");
5115 break;
5116 }
5117
5118 source << "}\n";
5119 return source.str();
5120 }
5121
texture_gather_offsets(NegativeTestContext & ctx)5122 void texture_gather_offsets(NegativeTestContext &ctx)
5123 {
5124 TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx) || ctx.isExtensionSupported("GL_EXT_gpu_shader5"),
5125 "This test requires a context version 3.2 or higher.");
5126
5127 const struct TextureGatherOffsetsTestSpec testSpecs[] = {
5128 //mode samplerDataType pDataType offsetsDataType fourthArgument offsetIsConst offsetArraySize
5129 {
5130 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5131 glu::TYPE_SAMPLER_2D,
5132 glu::TYPE_FLOAT_VEC2,
5133 glu::TYPE_INT_VEC2,
5134 glu::TYPE_LAST,
5135 false,
5136 4,
5137 },
5138 {
5139 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5140 glu::TYPE_SAMPLER_2D,
5141 glu::TYPE_FLOAT_VEC2,
5142 glu::TYPE_INT_VEC2,
5143 glu::TYPE_LAST,
5144 true,
5145 3,
5146 },
5147 {
5148 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5149 glu::TYPE_SAMPLER_2D,
5150 glu::TYPE_FLOAT,
5151 glu::TYPE_INT_VEC2,
5152 glu::TYPE_LAST,
5153 true,
5154 4,
5155 },
5156 {
5157 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5158 glu::TYPE_SAMPLER_2D,
5159 glu::TYPE_FLOAT_VEC2,
5160 glu::TYPE_INT,
5161 glu::TYPE_LAST,
5162 true,
5163 4,
5164 },
5165 {
5166 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5167 glu::TYPE_SAMPLER_2D,
5168 glu::TYPE_FLOAT_VEC2,
5169 glu::TYPE_INT_VEC2,
5170 glu::TYPE_INT,
5171 false,
5172 4,
5173 },
5174 {
5175 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5176 glu::TYPE_SAMPLER_2D,
5177 glu::TYPE_FLOAT_VEC2,
5178 glu::TYPE_INT_VEC2,
5179 glu::TYPE_FLOAT,
5180 true,
5181 4,
5182 },
5183 {
5184 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5185 glu::TYPE_SAMPLER_2D,
5186 glu::TYPE_FLOAT_VEC2,
5187 glu::TYPE_INT_VEC2,
5188 glu::TYPE_INT,
5189 true,
5190 3,
5191 },
5192 {
5193 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5194 glu::TYPE_SAMPLER_2D,
5195 glu::TYPE_FLOAT,
5196 glu::TYPE_INT_VEC2,
5197 glu::TYPE_INT,
5198 true,
5199 4,
5200 },
5201 {
5202 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5203 glu::TYPE_SAMPLER_2D,
5204 glu::TYPE_FLOAT_VEC2,
5205 glu::TYPE_INT,
5206 glu::TYPE_INT,
5207 true,
5208 4,
5209 },
5210
5211 {
5212 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5213 glu::TYPE_SAMPLER_2D_ARRAY,
5214 glu::TYPE_FLOAT_VEC3,
5215 glu::TYPE_INT_VEC2,
5216 glu::TYPE_LAST,
5217 false,
5218 4,
5219 },
5220 {
5221 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5222 glu::TYPE_SAMPLER_2D_ARRAY,
5223 glu::TYPE_FLOAT_VEC3,
5224 glu::TYPE_INT_VEC2,
5225 glu::TYPE_LAST,
5226 true,
5227 3,
5228 },
5229 {
5230 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5231 glu::TYPE_SAMPLER_2D_ARRAY,
5232 glu::TYPE_FLOAT,
5233 glu::TYPE_INT_VEC2,
5234 glu::TYPE_LAST,
5235 true,
5236 4,
5237 },
5238 {
5239 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5240 glu::TYPE_SAMPLER_2D_ARRAY,
5241 glu::TYPE_FLOAT_VEC3,
5242 glu::TYPE_INT,
5243 glu::TYPE_LAST,
5244 true,
5245 4,
5246 },
5247 {
5248 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5249 glu::TYPE_SAMPLER_2D_ARRAY,
5250 glu::TYPE_FLOAT_VEC3,
5251 glu::TYPE_INT_VEC2,
5252 glu::TYPE_INT,
5253 false,
5254 4,
5255 },
5256 {
5257 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5258 glu::TYPE_SAMPLER_2D_ARRAY,
5259 glu::TYPE_FLOAT_VEC3,
5260 glu::TYPE_INT_VEC2,
5261 glu::TYPE_FLOAT,
5262 true,
5263 4,
5264 },
5265 {
5266 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5267 glu::TYPE_SAMPLER_2D_ARRAY,
5268 glu::TYPE_FLOAT_VEC3,
5269 glu::TYPE_INT_VEC2,
5270 glu::TYPE_INT,
5271 true,
5272 3,
5273 },
5274 {
5275 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5276 glu::TYPE_SAMPLER_2D_ARRAY,
5277 glu::TYPE_FLOAT,
5278 glu::TYPE_INT_VEC2,
5279 glu::TYPE_INT,
5280 true,
5281 4,
5282 },
5283 {
5284 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_COMP,
5285 glu::TYPE_SAMPLER_2D_ARRAY,
5286 glu::TYPE_FLOAT_VEC3,
5287 glu::TYPE_INT,
5288 glu::TYPE_INT,
5289 true,
5290 4,
5291 },
5292
5293 {
5294 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5295 glu::TYPE_SAMPLER_2D_SHADOW,
5296 glu::TYPE_FLOAT_VEC2,
5297 glu::TYPE_INT_VEC2,
5298 glu::TYPE_FLOAT,
5299 false,
5300 4,
5301 },
5302 {
5303 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5304 glu::TYPE_SAMPLER_2D_SHADOW,
5305 glu::TYPE_FLOAT_VEC2,
5306 glu::TYPE_INT_VEC2,
5307 glu::TYPE_FLOAT,
5308 true,
5309 3,
5310 },
5311 {
5312 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5313 glu::TYPE_SAMPLER_2D_SHADOW,
5314 glu::TYPE_FLOAT,
5315 glu::TYPE_INT_VEC2,
5316 glu::TYPE_FLOAT,
5317 true,
5318 4,
5319 },
5320 {
5321 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5322 glu::TYPE_SAMPLER_2D_SHADOW,
5323 glu::TYPE_FLOAT_VEC2,
5324 glu::TYPE_INT,
5325 glu::TYPE_FLOAT,
5326 true,
5327 4,
5328 },
5329 {
5330 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5331 glu::TYPE_SAMPLER_2D_SHADOW,
5332 glu::TYPE_FLOAT_VEC2,
5333 glu::TYPE_INT_VEC2,
5334 glu::TYPE_INT,
5335 true,
5336 4,
5337 },
5338
5339 {
5340 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5341 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
5342 glu::TYPE_FLOAT_VEC3,
5343 glu::TYPE_INT_VEC2,
5344 glu::TYPE_FLOAT,
5345 false,
5346 4,
5347 },
5348 {
5349 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5350 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
5351 glu::TYPE_FLOAT_VEC3,
5352 glu::TYPE_INT_VEC2,
5353 glu::TYPE_FLOAT,
5354 true,
5355 3,
5356 },
5357 {
5358 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5359 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
5360 glu::TYPE_FLOAT,
5361 glu::TYPE_INT_VEC2,
5362 glu::TYPE_FLOAT,
5363 true,
5364 4,
5365 },
5366 {
5367 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5368 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
5369 glu::TYPE_FLOAT_VEC3,
5370 glu::TYPE_INT,
5371 glu::TYPE_FLOAT,
5372 true,
5373 4,
5374 },
5375 {
5376 FUNCTION_TEXTURE_GATHER_OFFSET_MODE_REF_Z,
5377 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
5378 glu::TYPE_FLOAT_VEC3,
5379 glu::TYPE_INT_VEC2,
5380 glu::TYPE_INT,
5381 true,
5382 4,
5383 },
5384 };
5385
5386 ctx.beginSection("textureGatherOffsets");
5387 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
5388 {
5389 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
5390 {
5391 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
5392 for (int specNdx = 0; specNdx < DE_LENGTH_OF_ARRAY(testSpecs); ++specNdx)
5393 {
5394 const std::string shaderSource(
5395 genShaderSourceTextureGatherOffsets(ctx, s_shaders[shaderNdx], testSpecs[specNdx]));
5396 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5397 }
5398 ctx.endSection();
5399 }
5400 }
5401 ctx.endSection();
5402 }
5403
5404 // fma
genShaderSourceFma(NegativeTestContext & ctx,glu::ShaderType shaderType,glu::DataType aDataType,glu::DataType bDataType,glu::DataType cDataType)5405 std::string genShaderSourceFma(NegativeTestContext &ctx, glu::ShaderType shaderType, glu::DataType aDataType,
5406 glu::DataType bDataType, glu::DataType cDataType)
5407 {
5408 std::ostringstream source;
5409
5410 source << (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ?
5411 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
5412 glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES))
5413 << "\n"
5414 << getShaderInitialization(ctx, shaderType) << "void main(void)\n"
5415 << "{\n"
5416 << " mediump " << declareAndInitializeShaderVariable(aDataType, "a") << " mediump "
5417 << declareAndInitializeShaderVariable(bDataType, "b") << " mediump "
5418 << declareAndInitializeShaderVariable(cDataType, "c") << " fma(a, b, c);"
5419 << "}\n";
5420 return source.str();
5421 }
5422
fma(NegativeTestContext & ctx)5423 void fma(NegativeTestContext &ctx)
5424 {
5425 TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx) || ctx.isExtensionSupported("GL_EXT_gpu_shader5"),
5426 "This test requires a context version 3.2 or higher.");
5427
5428 ctx.beginSection("fma");
5429 for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(s_shaders); ++shaderNdx)
5430 {
5431 if (ctx.isShaderSupported(s_shaders[shaderNdx]))
5432 {
5433 ctx.beginSection("Verify shader: " + std::string(getShaderTypeName(s_shaders[shaderNdx])));
5434 {
5435 const std::string shaderSource(
5436 genShaderSourceFma(ctx, s_shaders[shaderNdx], glu::TYPE_FLOAT, glu::TYPE_FLOAT, glu::TYPE_INT));
5437 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5438 }
5439 {
5440 const std::string shaderSource(
5441 genShaderSourceFma(ctx, s_shaders[shaderNdx], glu::TYPE_FLOAT, glu::TYPE_INT, glu::TYPE_FLOAT));
5442 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5443 }
5444 {
5445 const std::string shaderSource(
5446 genShaderSourceFma(ctx, s_shaders[shaderNdx], glu::TYPE_INT, glu::TYPE_FLOAT, glu::TYPE_FLOAT));
5447 verifyShader(ctx, s_shaders[shaderNdx], shaderSource);
5448 }
5449 ctx.endSection();
5450 }
5451 }
5452 ctx.endSection();
5453 }
5454
5455 } // namespace Functional
5456
getNegativeShaderFunctionTestFunctions()5457 std::vector<FunctionContainer> getNegativeShaderFunctionTestFunctions()
5458 {
5459 const FunctionContainer funcs[] = {
5460 {bitfield_extract_invalid_value_type, "bitfield_extract_invalid_value_type",
5461 "Invalid usage of bitfieldExtract."},
5462 {bitfield_extract_invalid_offset_type, "bitfield_extract_invalid_offset_type",
5463 "Invalid usage of bitfieldExtract."},
5464 {bitfield_extract_invalid_bits_type, "bitfield_extract_invalid_bits_type", "Invalid usage of bitfieldExtract."},
5465 {bitfield_insert_invalid_base_type, "bitfield_insert_invalid_base_type", "Invalid usage of bitfieldInsert."},
5466 {bitfield_insert_invalid_insert_type, "bitfield_insert_invalid_insert_type",
5467 "Invalid usage of bitfieldInsert."},
5468 {bitfield_insert_invalid_offset_type, "bitfield_insert_invalid_offset_type",
5469 "Invalid usage of bitfieldInsert."},
5470 {bitfield_insert_invalid_bits_type, "bitfield_insert_invalid_bits_type", "Invalid usage of bitfieldInsert."},
5471 {bitfield_reverse, "bitfield_reverse", "Invalid usage of bitfieldReverse."},
5472 {bit_count, "bit_count", "Invalid usage of bitCount."},
5473 {find_msb, "find_msb", "Invalid usage of findMSB."},
5474 {find_lsb, "find_lsb", "Invalid usage of findLSB."},
5475 {uadd_carry_invalid_x, "uadd_carry_invalid_x", "Invalid usage of uaddCarry."},
5476 {uadd_carry_invalid_y, "uadd_carry_invalid_y", "Invalid usage of uaddCarry."},
5477 {uadd_carry_invalid_carry, "uadd_carry_invalid_carry", "Invalid usage of uaddCarry."},
5478 {usub_borrow_invalid_x, "usub_borrow_invalid_x", "Invalid usage of usubBorrow."},
5479 {usub_borrow_invalid_y, "usub_borrow_invalid_y", "Invalid usage of usubBorrow."},
5480 {usub_borrow_invalid_borrow, "usub_borrow_invalid_borrow", "Invalid usage of usubBorrow."},
5481 {umul_extended_invalid_x, "umul_extended_invalid_x", "Invalid usage of umulExtended."},
5482 {umul_extended_invalid_y, "umul_extended_invalid_y", "Invalid usage of umulExtended."},
5483 {umul_extended_invalid_msb, "umul_extended_invalid_msb", "Invalid usage of umulExtended."},
5484 {umul_extended_invalid_lsb, "umul_extended_invalid_lsb", "Invalid usage of umulExtended."},
5485 {imul_extended_invalid_x, "imul_extended_invalid_x", "Invalid usage of imulExtended."},
5486 {imul_extended_invalid_y, "imul_extended_invalid_y", "Invalid usage of imulExtended."},
5487 {imul_extended_invalid_msb, "imul_extended_invalid_msb", "Invalid usage of imulExtended."},
5488 {imul_extended_invalid_lsb, "imul_extended_invalid_lsb", "Invalid usage of imulExtended."},
5489 {frexp_invalid_x, "frexp_invalid_x", "Invalid usage of frexp."},
5490 {frexp_invalid_exp, "frexp_invalid_exp", "Invalid usage of frexp."},
5491 {ldexp_invalid_x, "ldexp_invalid_x", "Invalid usage of ldexp."},
5492 {ldexp_invalid_exp, "ldexp_invalid_exp", "Invalid usage of ldexp."},
5493 {pack_unorm_4x8, "pack_unorm_4x8", "Invalid usage of packUnorm4x8."},
5494 {pack_snorm_4x8, "pack_snorm_4x8", "Invalid usage of packSnorm4x8."},
5495 {unpack_snorm_4x8, "unpack_snorm_4x8", "Invalid usage of unpackSnorm4x8."},
5496 {unpack_unorm_4x8, "unpack_unorm_4x8", "Invalid usage of unpackUnorm4x8."},
5497 {texture_size_invalid_sampler, "texture_size_invalid_sampler", "Invalid usage of textureSize."},
5498 {texture_size_invalid_lod, "texture_size_invalid_lod", "Invalid usage of textureSize."},
5499 {texture_invalid_p, "texture_invalid_p", "Invalid usage of texture."},
5500 {texture_invalid_bias_or_compare, "texture_invalid_bias_or_compare", "Invalid usage of texture."},
5501 {texture_lod_invalid_p, "texture_lod_invalid_p", "Invalid usage of textureLod."},
5502 {texture_lod_invalid_lod, "texture_lod_invalid_lod", "Invalid usage of textureLod."},
5503 {texel_fetch_invalid_p, "texel_fetch_invalid_p", "Invalid usage of texelFetch."},
5504 {texel_fetch_invalid_sample, "texel_fetch_invalid_sample", "Invalid usage of texelFetch."},
5505 {emit_vertex, "emit_vertex", "Invalid usage of EmitVertex."},
5506 {end_primitive, "end_primitive", "Invalid usage of EndPrimitive."},
5507 {texture_grad, "texture_grad", "Invalid usage of textureGrad."},
5508 {texture_gather_sampler_2d, "texture_gather_sampler_2d", "Invalid usage of textureGather."},
5509 {texture_gather_sampler_2d_array, "texture_gather_sampler_2d_array", "Invalid usage of textureGather."},
5510 {texture_gather_sampler_cube, "texture_gather_sampler_cube", "Invalid usage of textureGather."},
5511 {texture_gather_sampler_2d_shadow, "texture_gather_sampler_2d_shadow", "Invalid usage of textureGather."},
5512 {texture_gather_sampler_2d_array_shadow, "texture_gather_sampler_2d_array_shadow",
5513 "Invalid usage of textureGather."},
5514 {texture_gather_sampler_cube_shadow, "texture_gather_sampler_cube_shadow", "Invalid usage of textureGather."},
5515 {texture_gather_sampler_cube_array, "texture_gather_sampler_cube_array", "Invalid usage of textureGather."},
5516 {texture_gather_sampler_cube_array_shadow, "texture_gather_sampler_cube_array_shadow",
5517 "Invalid usage of textureGather."},
5518 {texture_gather_offset_sampler_2d, "texture_gather_offset_sampler_2d", "Invalid usage of textureGatherOffset."},
5519 {texture_gather_offset_sampler_2d_array, "texture_gather_offset_sampler_2d_array",
5520 "Invalid usage of textureGatherOffset."},
5521 {texture_gather_offset_sampler_2d_shadow, "texture_gather_offset_sampler_2d_shadow",
5522 "Invalid usage of textureGatherOffset."},
5523 {texture_gather_offset_sampler_2d_array_shadow, "texture_gather_offset_sampler_2d_array_shadow",
5524 "Invalid usage of textureGatherOffset."},
5525 {texture_gather_offsets, "texture_gather_offsets", "Invalid usage of textureGatherOffsets."},
5526 {atomic_add, "atomic_add", "Invalid usage of atomicAdd."},
5527 {atomic_min, "atomic_min", "Invalid usage of atomicMin."},
5528 {atomic_max, "atomic_max", "Invalid usage of atomicMax."},
5529 {atomic_and, "atomic_and", "Invalid usage of atomicAnd."},
5530 {atomic_or, "atomic_or", "Invalid usage of atomicOr."},
5531 {atomic_xor, "atomic_xor", "Invalid usage of atomicXor."},
5532 {atomic_exchange, "atomic_exchange", "Invalid usage of atomicExchange."},
5533 {atomic_comp_swap, "atomic_comp_swap", "Invalid usage of atomicCompSwap."},
5534 {interpolate_at_centroid, "interpolate_at_centroid", "Invalid usage of interpolateAtCentroid."},
5535 {interpolate_at_sample, "interpolate_at_sample", "Invalid usage of interpolateAtSample."},
5536 {interpolate_at_offset, "interpolate_at_offset", "Invalid usage of interpolateAtOffset."},
5537 {fma, "fma", "Invalid usage of fma."},
5538 };
5539
5540 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
5541 }
5542
5543 } // namespace gles31
5544 } // namespace deqp
5545 } // gles31
5546 } // deqp
5547