modules/gles31/functional/es31fNegativeShaderFunctionTests.cpp

   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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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,
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
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
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
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
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
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
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
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
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
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