Home | History | Annotate | Download | only in functional 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 3.1 Module
      3  * -------------------------------------------------
      4  *
      5  * Copyright 2015 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 Image Load Store Tests
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es31fNegativeShaderImageLoadStoreTests.hpp"
     25 
     26 #include "deUniquePtr.hpp"
     27 
     28 #include "glwEnums.hpp"
     29 
     30 #include "gluShaderProgram.hpp"
     31 
     32 #include "glsTextureTestUtil.hpp"
     33 
     34 #include "tcuStringTemplate.hpp"
     35 #include "tcuTexture.hpp"
     36 #include "tcuTestLog.hpp"
     37 
     38 namespace deqp
     39 {
     40 namespace gles31
     41 {
     42 namespace Functional
     43 {
     44 namespace NegativeTestShared
     45 {
     46 namespace
     47 {
     48 
     49 enum MemoryQualifier
     50 {
     51 	MEMORY_NONE = 0,
     52 	MEMORY_READONLY,
     53 	MEMORY_WRITEONLY,
     54 	MEMORY_BOTH,
     55 
     56 	MEMORY_LAST
     57 };
     58 
     59 enum ImageOperation
     60 {
     61 	IMAGE_OPERATION_STORE = 0,
     62 	IMAGE_OPERATION_LOAD,
     63 	IMAGE_OPERATION_ATOMIC_ADD,
     64 	IMAGE_OPERATION_ATOMIC_MIN,
     65 	IMAGE_OPERATION_ATOMIC_MAX,
     66 	IMAGE_OPERATION_ATOMIC_AND,
     67 	IMAGE_OPERATION_ATOMIC_OR,
     68 	IMAGE_OPERATION_ATOMIC_XOR,
     69 	IMAGE_OPERATION_ATOMIC_EXCHANGE,
     70 	IMAGE_OPERATION_ATOMIC_COMP_SWAP,
     71 
     72 	IMAGE_OPERATION_LAST
     73 };
     74 
     75 static const glu::ShaderType s_shaders[] =
     76 {
     77 	glu::SHADERTYPE_VERTEX,
     78 	glu::SHADERTYPE_FRAGMENT,
     79 	glu::SHADERTYPE_GEOMETRY,
     80 	glu::SHADERTYPE_TESSELLATION_CONTROL,
     81 	glu::SHADERTYPE_TESSELLATION_EVALUATION,
     82 	glu::SHADERTYPE_COMPUTE
     83 };
     84 
     85 std::string getShaderImageLayoutQualifier (const tcu::TextureFormat& format)
     86 {
     87 	std::ostringstream qualifier;
     88 
     89 	switch (format.order)
     90 	{
     91 		case tcu::TextureFormat::RGBA:	qualifier << "rgba";	break;
     92 		case tcu::TextureFormat::R:		qualifier << "r";		break;
     93 		default:
     94 			DE_ASSERT(false);
     95 			return std::string("");
     96 	}
     97 
     98 	switch (format.type)
     99 	{
    100 		case tcu::TextureFormat::FLOAT:				qualifier << "32f";			break;
    101 		case tcu::TextureFormat::HALF_FLOAT:		qualifier << "16f";			break;
    102 		case tcu::TextureFormat::UNORM_INT8:		qualifier << "8";			break;
    103 		case tcu::TextureFormat::SNORM_INT8:		qualifier << "8_snorm";		break;
    104 		case tcu::TextureFormat::SIGNED_INT32:		qualifier << "32i";			break;
    105 		case tcu::TextureFormat::SIGNED_INT16:		qualifier << "16i";			break;
    106 		case tcu::TextureFormat::SIGNED_INT8:		qualifier << "8i";			break;
    107 		case tcu::TextureFormat::UNSIGNED_INT32:	qualifier << "32ui";		break;
    108 		case tcu::TextureFormat::UNSIGNED_INT16:	qualifier << "16ui";		break;
    109 		case tcu::TextureFormat::UNSIGNED_INT8:		qualifier << "8ui";			break;
    110 		default:
    111 			DE_ASSERT(false);
    112 			return std::string("");
    113 	}
    114 
    115 	return qualifier.str();
    116 }
    117 
    118 std::string getShaderImageTypeDeclaration (const tcu::TextureFormat& format, glu::TextureTestUtil::TextureType imageType)
    119 {
    120 	std::ostringstream declaration;
    121 
    122 	switch (format.type)
    123 	{
    124 		case tcu::TextureFormat::FLOAT:
    125 		case tcu::TextureFormat::HALF_FLOAT:
    126 		case tcu::TextureFormat::UNORM_INT8:
    127 		case tcu::TextureFormat::SNORM_INT8:		declaration << "";		break;
    128 
    129 		case tcu::TextureFormat::SIGNED_INT32:
    130 		case tcu::TextureFormat::SIGNED_INT16:
    131 		case tcu::TextureFormat::SIGNED_INT8:		declaration << "i";		break;
    132 
    133 		case tcu::TextureFormat::UNSIGNED_INT32:
    134 		case tcu::TextureFormat::UNSIGNED_INT16:
    135 		case tcu::TextureFormat::UNSIGNED_INT8:		declaration << "u";		break;
    136 
    137 		default:
    138 			DE_ASSERT(false);
    139 			return std::string("");
    140 	}
    141 
    142 	declaration << "image";
    143 
    144 	switch(imageType)
    145 	{
    146 		case glu::TextureTestUtil::TEXTURETYPE_2D:			declaration << "2D";			break;
    147 		case glu::TextureTestUtil::TEXTURETYPE_3D:			declaration << "3D";			break;
    148 		case glu::TextureTestUtil::TEXTURETYPE_CUBE:		declaration << "Cube";			break;
    149 		case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:	declaration << "2DArray";		break;
    150 		case glu::TextureTestUtil::TEXTURETYPE_BUFFER:		declaration << "Buffer";		break;
    151 		case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:	declaration << "CubeArray";		break;
    152 		default:
    153 			DE_ASSERT(false);
    154 			return std::string("");
    155 	}
    156 
    157 	return declaration.str();
    158 }
    159 
    160 std::string getShaderImageTypeExtensionString (glu::TextureTestUtil::TextureType imageType)
    161 {
    162 	std::string extension;
    163 
    164 	switch(imageType)
    165 	{
    166 		case glu::TextureTestUtil::TEXTURETYPE_2D:
    167 		case glu::TextureTestUtil::TEXTURETYPE_3D:
    168 		case glu::TextureTestUtil::TEXTURETYPE_CUBE:
    169 		case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
    170 			extension = "";
    171 			break;
    172 
    173 		case glu::TextureTestUtil::TEXTURETYPE_BUFFER:
    174 			extension = "#extension GL_EXT_texture_buffer : enable";
    175 			break;
    176 
    177 		case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
    178 			extension = "#extension GL_EXT_texture_cube_map_array : enable";
    179 			break;
    180 
    181 		default:
    182 			DE_ASSERT(false);
    183 			return std::string("");
    184 	}
    185 
    186 	return extension;
    187 }
    188 
    189 std::string getShaderImageParamP (glu::TextureTestUtil::TextureType imageType)
    190 {
    191 	switch(imageType)
    192 	{
    193 		case glu::TextureTestUtil::TEXTURETYPE_2D:
    194 			return "ivec2(1, 1)";
    195 
    196 		case glu::TextureTestUtil::TEXTURETYPE_3D:
    197 		case glu::TextureTestUtil::TEXTURETYPE_CUBE:
    198 		case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
    199 		case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
    200 			return "ivec3(1, 1, 1)";
    201 
    202 		case glu::TextureTestUtil::TEXTURETYPE_BUFFER:
    203 			return "1";
    204 
    205 		default:
    206 			DE_ASSERT(false);
    207 			return std::string("");
    208 	}
    209 }
    210 
    211 std::string getOtherFunctionArguments (const tcu::TextureFormat& format, ImageOperation function)
    212 {
    213 	std::ostringstream data;
    214 	data << ", ";
    215 
    216 	bool isFloat = false;
    217 
    218 	switch(format.type)
    219 	{
    220 		case tcu::TextureFormat::FLOAT:
    221 		case tcu::TextureFormat::HALF_FLOAT:
    222 		case tcu::TextureFormat::UNORM_INT8:
    223 		case tcu::TextureFormat::SNORM_INT8:
    224 			data << "";
    225 			isFloat = true;
    226 			break;
    227 
    228 		case tcu::TextureFormat::SIGNED_INT32:
    229 		case tcu::TextureFormat::SIGNED_INT16:
    230 		case tcu::TextureFormat::SIGNED_INT8:
    231 			data << "i";
    232 			break;
    233 
    234 		case tcu::TextureFormat::UNSIGNED_INT32:
    235 		case tcu::TextureFormat::UNSIGNED_INT16:
    236 		case tcu::TextureFormat::UNSIGNED_INT8:
    237 			data << "u";
    238 			break;
    239 
    240 		default:
    241 			DE_ASSERT(false);
    242 			return std::string("");
    243 	}
    244 
    245 	switch (function)
    246 	{
    247 		case IMAGE_OPERATION_LOAD:
    248 			return "";
    249 
    250 		case IMAGE_OPERATION_STORE:
    251 			data << "vec4(1, 1, 1, 1)";
    252 			break;
    253 
    254 		case IMAGE_OPERATION_ATOMIC_ADD:
    255 		case IMAGE_OPERATION_ATOMIC_MIN:
    256 		case IMAGE_OPERATION_ATOMIC_MAX:
    257 		case IMAGE_OPERATION_ATOMIC_AND:
    258 		case IMAGE_OPERATION_ATOMIC_OR:
    259 		case IMAGE_OPERATION_ATOMIC_XOR:
    260 			return ", 1";
    261 
    262 		case IMAGE_OPERATION_ATOMIC_EXCHANGE:
    263 			return isFloat ? ", 1.0" : ", 1";
    264 
    265 		case IMAGE_OPERATION_ATOMIC_COMP_SWAP:
    266 			return ", 1, 1";
    267 
    268 		default:
    269 			DE_ASSERT(false);
    270 			return std::string("");
    271 	}
    272 	return data.str();
    273 }
    274 
    275 std::string getMemoryQualifier (MemoryQualifier memory)
    276 {
    277 	switch (memory)
    278 	{
    279 		case MEMORY_NONE:
    280 			return std::string("");
    281 
    282 		case MEMORY_WRITEONLY:
    283 			return std::string("writeonly");
    284 
    285 		case MEMORY_READONLY:
    286 			return std::string("readonly");
    287 
    288 		case MEMORY_BOTH:
    289 			return std::string("writeonly readonly");
    290 
    291 		default:
    292 			DE_ASSERT(DE_FALSE);
    293 	}
    294 
    295 	return std::string("");
    296 }
    297 
    298 std::string getShaderImageFunctionExtensionString (ImageOperation function)
    299 {
    300 	switch (function)
    301 	{
    302 		case IMAGE_OPERATION_STORE:
    303 		case IMAGE_OPERATION_LOAD:
    304 			return std::string("");
    305 
    306 		case IMAGE_OPERATION_ATOMIC_ADD:
    307 		case IMAGE_OPERATION_ATOMIC_MIN:
    308 		case IMAGE_OPERATION_ATOMIC_MAX:
    309 		case IMAGE_OPERATION_ATOMIC_AND:
    310 		case IMAGE_OPERATION_ATOMIC_OR:
    311 		case IMAGE_OPERATION_ATOMIC_XOR:
    312 		case IMAGE_OPERATION_ATOMIC_EXCHANGE:
    313 		case IMAGE_OPERATION_ATOMIC_COMP_SWAP:
    314 			return std::string("#extension GL_OES_shader_image_atomic : enable");
    315 
    316 		default:
    317 			DE_ASSERT(DE_FALSE);
    318 	}
    319 	return std::string("");
    320 }
    321 
    322 std::string getFunctionName (ImageOperation function)
    323 {
    324 	switch (function)
    325 	{
    326 		case IMAGE_OPERATION_STORE:				return std::string("imageStore");
    327 		case IMAGE_OPERATION_LOAD:				return std::string("imageLoad");
    328 		case IMAGE_OPERATION_ATOMIC_ADD:		return std::string("imageAtomicAdd");
    329 		case IMAGE_OPERATION_ATOMIC_MIN:		return std::string("imageAtomicMin");
    330 		case IMAGE_OPERATION_ATOMIC_MAX:		return std::string("imageAtomicMax");
    331 		case IMAGE_OPERATION_ATOMIC_AND:		return std::string("imageAtomicAnd");
    332 		case IMAGE_OPERATION_ATOMIC_OR:			return std::string("imageAtomicOr");
    333 		case IMAGE_OPERATION_ATOMIC_XOR:		return std::string("imageAtomicXor");
    334 		case IMAGE_OPERATION_ATOMIC_EXCHANGE:	return std::string("imageAtomicExchange");
    335 		case IMAGE_OPERATION_ATOMIC_COMP_SWAP:	return std::string("imageAtomicCompSwap");
    336 		default:
    337 			DE_ASSERT(DE_FALSE);
    338 	}
    339 	return std::string("");
    340 }
    341 
    342 std::string generateShaderSource (ImageOperation function, MemoryQualifier memory, glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format, glu::ShaderType shaderType)
    343 {
    344 	const char* shaderTemplate =	"${GLSL_VERSION_DECL}\n"
    345 									"${GLSL_TYPE_EXTENSION}\n"
    346 									"${GLSL_FUNCTION_EXTENSION}\n"
    347 									"${GEOMETRY_SHADER_LAYOUT}\n"
    348 									"layout(${LAYOUT_FORMAT}, binding = 0) highp uniform ${MEMORY_QUALIFIER} ${IMAGE_TYPE} u_img0;\n"
    349 									"void main(void)\n"
    350 									"{\n"
    351 									" ${FUNCTION_NAME}(u_img0, ${IMAGE_PARAM_P}${FUNCTION_ARGUMENTS});\n"
    352 									"}\n";
    353 
    354 	std::map<std::string, std::string> params;
    355 
    356 	params["GLSL_VERSION_DECL"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    357 	params["GLSL_TYPE_EXTENSION"] = getShaderImageTypeExtensionString(imageType);
    358 	params["GLSL_FUNCTION_EXTENSION"] = getShaderImageFunctionExtensionString(function);
    359 	params["GEOMETRY_SHADER_LAYOUT"] = getGLShaderType(shaderType) == GL_GEOMETRY_SHADER ? "layout(max_vertices = 3) out;" : "";
    360 	params["LAYOUT_FORMAT"] = getShaderImageLayoutQualifier(format);
    361 	params["MEMORY_QUALIFIER"] = getMemoryQualifier(memory);
    362 	params["IMAGE_TYPE"] = getShaderImageTypeDeclaration(format, imageType);
    363 	params["FUNCTION_NAME"] = getFunctionName(function);
    364 	params["IMAGE_PARAM_P"] = getShaderImageParamP(imageType);
    365 	params["FUNCTION_ARGUMENTS"] = getOtherFunctionArguments(format, function);
    366 
    367 	return tcu::StringTemplate(shaderTemplate).specialize(params);
    368 }
    369 
    370 void testShader (NegativeTestContext& ctx, ImageOperation function, MemoryQualifier memory, glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format)
    371 {
    372 	tcu::TestLog& log = ctx.getLog();
    373 	ctx.beginSection(getFunctionName(function) + " " + getMemoryQualifier(memory) + " " + getShaderImageLayoutQualifier(format));
    374 	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaders); ndx++)
    375 	{
    376 		if (ctx.isShaderSupported(s_shaders[ndx]))
    377 		{
    378 			ctx.beginSection(std::string("Verify shader: ") + glu::getShaderTypeName(s_shaders[ndx]));
    379 			std::string					shaderSource(generateShaderSource(function, memory, imageType, format, s_shaders[ndx]));
    380 			const glu::ShaderProgram	program(ctx.getRenderContext(), glu::ProgramSources() << glu::ShaderSource(s_shaders[ndx], shaderSource));
    381 			if (program.getShaderInfo(s_shaders[ndx]).compileOk)
    382 			{
    383 				log << program;
    384 				log << tcu::TestLog::Message << "Expected program to fail, but compilation passed." << tcu::TestLog::EndMessage;
    385 				ctx.fail("Shader was not expected to compile.");
    386 			}
    387 			ctx.endSection();
    388 		}
    389 	}
    390 	ctx.endSection();
    391 }
    392 
    393 void image_store (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
    394 {
    395 	const tcu::TextureFormat formats[] =
    396 	{
    397 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::FLOAT),
    398 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::HALF_FLOAT),
    399 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::FLOAT),
    400 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNORM_INT8),
    401 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SNORM_INT8),
    402 
    403 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT32),
    404 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT16),
    405 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT8),
    406 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::SIGNED_INT32),
    407 
    408 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT32),
    409 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT16),
    410 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT8),
    411 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::UNSIGNED_INT32)
    412 	};
    413 
    414 	const MemoryQualifier memoryOptions[] =
    415 	{
    416 		MEMORY_READONLY,
    417 		MEMORY_BOTH
    418 	};
    419 
    420 	ctx.beginSection("It is an error to pass a readonly image to imageStore.");
    421 	for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx)
    422 	{
    423 		for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
    424 		{
    425 			testShader(ctx, IMAGE_OPERATION_STORE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
    426 		}
    427 	}
    428 	ctx.endSection();
    429 }
    430 
    431 void image_load (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
    432 {
    433 	const tcu::TextureFormat formats[] =
    434 	{
    435 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::FLOAT),
    436 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::HALF_FLOAT),
    437 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::FLOAT),
    438 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNORM_INT8),
    439 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SNORM_INT8),
    440 
    441 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT32),
    442 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT16),
    443 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT8),
    444 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::SIGNED_INT32),
    445 
    446 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT32),
    447 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT16),
    448 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT8),
    449 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::UNSIGNED_INT32)
    450 	};
    451 
    452 	const MemoryQualifier memoryOptions[] =
    453 	{
    454 		MEMORY_WRITEONLY,
    455 		MEMORY_BOTH
    456 	};
    457 
    458 	ctx.beginSection("It is an error to pass a writeonly image to imageLoad.");
    459 	for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx)
    460 	{
    461 		for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
    462 		{
    463 			testShader(ctx, IMAGE_OPERATION_LOAD, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
    464 		}
    465 	}
    466 	ctx.endSection();
    467 }
    468 
    469 void image_atomic (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
    470 {
    471 	const tcu::TextureFormat formats[] =
    472 	{
    473 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT32),
    474 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT16),
    475 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT8),
    476 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::SIGNED_INT32),
    477 
    478 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT32),
    479 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT16),
    480 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT8),
    481 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::UNSIGNED_INT32)
    482 	};
    483 
    484 	const MemoryQualifier memoryOptions[] =
    485 	{
    486 		MEMORY_READONLY,
    487 		MEMORY_WRITEONLY,
    488 		MEMORY_BOTH
    489 	};
    490 
    491 	const ImageOperation imageOperations[] =
    492 	{
    493 		IMAGE_OPERATION_ATOMIC_ADD,
    494 		IMAGE_OPERATION_ATOMIC_MIN,
    495 		IMAGE_OPERATION_ATOMIC_MAX,
    496 		IMAGE_OPERATION_ATOMIC_AND,
    497 		IMAGE_OPERATION_ATOMIC_OR,
    498 		IMAGE_OPERATION_ATOMIC_XOR,
    499 		IMAGE_OPERATION_ATOMIC_COMP_SWAP
    500 	};
    501 
    502 	ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*.");
    503 	for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx)
    504 	{
    505 		for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
    506 		{
    507 			for (int functionNdx = 0; functionNdx < DE_LENGTH_OF_ARRAY(imageOperations); ++functionNdx)
    508 			{
    509 				testShader(ctx, imageOperations[functionNdx], memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
    510 			}
    511 		}
    512 	}
    513 	ctx.endSection();
    514 }
    515 
    516 void image_atomic_exchange (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
    517 {
    518 	const tcu::TextureFormat formats[] =
    519 	{
    520 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::FLOAT),
    521 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::HALF_FLOAT),
    522 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::FLOAT),
    523 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNORM_INT8),
    524 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SNORM_INT8),
    525 
    526 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT32),
    527 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT16),
    528 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::SIGNED_INT8),
    529 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::SIGNED_INT32),
    530 
    531 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT32),
    532 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT16),
    533 		tcu::TextureFormat(tcu::TextureFormat::RGBA,	tcu::TextureFormat::UNSIGNED_INT8),
    534 		tcu::TextureFormat(tcu::TextureFormat::R,		tcu::TextureFormat::UNSIGNED_INT32)
    535 	};
    536 
    537 	const MemoryQualifier memoryOptions[] =
    538 	{
    539 		MEMORY_READONLY,
    540 		MEMORY_WRITEONLY,
    541 		MEMORY_BOTH
    542 	};
    543 
    544 	ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*.");
    545 	for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx)
    546 	{
    547 		for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
    548 		{
    549 			testShader(ctx, IMAGE_OPERATION_ATOMIC_EXCHANGE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
    550 		}
    551 	}
    552 	ctx.endSection();
    553 }
    554 
    555 // Re-routing function template for generating the standard negative
    556 // test function signature with texture type added.
    557 
    558 template <int Type>
    559 void loadFuncWrapper (NegativeTestContext& ctx)
    560 {
    561 	image_load(ctx, (glu::TextureTestUtil::TextureType)Type);
    562 }
    563 
    564 template <int Type>
    565 void storeFuncWrapper (NegativeTestContext& ctx)
    566 {
    567 	image_store(ctx, (glu::TextureTestUtil::TextureType)Type);
    568 }
    569 
    570 template <int Type>
    571 void atomicFuncWrapper (NegativeTestContext& ctx)
    572 {
    573 	image_atomic(ctx, (glu::TextureTestUtil::TextureType)Type);
    574 }
    575 
    576 template <int Type>
    577 void atomicExchangeFuncWrapper (NegativeTestContext& ctx)
    578 {
    579 	image_atomic_exchange(ctx, (glu::TextureTestUtil::TextureType)Type);
    580 }
    581 
    582 } // anonymous
    583 
    584 // Set of texture types to create tests for.
    585 #define CREATE_TEST_FUNC_PER_TEXTURE_TYPE(NAME, FUNC) const FunctionContainer NAME[] =									\
    586 	{																													\
    587 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_2D>,			"texture_2d",	"Texture2D negative tests."},			\
    588 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_3D>,			"texture_3d",	"Texture3D negative tests."},			\
    589 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE>,			"cube",			"Cube texture negative tests."},		\
    590 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY>,		"2d_array",		"2D array texture negative tests."},	\
    591 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_BUFFER>,		"buffer",		"Buffer negative tests."},				\
    592 		{FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY>,	"cube_array",	"Cube array texture negative tests."}	\
    593 	}
    594 
    595 std::vector<FunctionContainer> getNegativeShaderImageLoadTestFunctions (void)
    596 {
    597 	CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, loadFuncWrapper);
    598 	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
    599 }
    600 
    601 std::vector<FunctionContainer> getNegativeShaderImageStoreTestFunctions (void)
    602 {
    603 	CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, storeFuncWrapper);
    604 	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
    605 }
    606 
    607 std::vector<FunctionContainer> getNegativeShaderImageAtomicTestFunctions (void)
    608 {
    609 	CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicFuncWrapper);
    610 	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
    611 }
    612 
    613 std::vector<FunctionContainer> getNegativeShaderImageAtomicExchangeTestFunctions (void)
    614 {
    615 	CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicExchangeFuncWrapper);
    616 	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
    617 }
    618 
    619 } // NegativeTestShared
    620 } // Functional
    621 } // gles31
    622 } // deqp
    623