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
