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