| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.1 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Negative Shader Image Load Store Tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es31fNegativeShaderImageLoadStoreTests.hpp" |
| |
| #include "deUniquePtr.hpp" |
| |
| #include "glwEnums.hpp" |
| |
| #include "gluShaderProgram.hpp" |
| |
| #include "glsTextureTestUtil.hpp" |
| |
| #include "tcuStringTemplate.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTestLog.hpp" |
| |
| namespace deqp |
| { |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| namespace NegativeTestShared |
| { |
| namespace |
| { |
| |
| enum MemoryQualifier |
| { |
| MEMORY_NONE = 0, |
| MEMORY_READONLY, |
| MEMORY_WRITEONLY, |
| MEMORY_BOTH, |
| |
| MEMORY_LAST |
| }; |
| |
| enum ImageOperation |
| { |
| IMAGE_OPERATION_STORE = 0, |
| IMAGE_OPERATION_LOAD, |
| IMAGE_OPERATION_ATOMIC_ADD, |
| IMAGE_OPERATION_ATOMIC_MIN, |
| IMAGE_OPERATION_ATOMIC_MAX, |
| IMAGE_OPERATION_ATOMIC_AND, |
| IMAGE_OPERATION_ATOMIC_OR, |
| IMAGE_OPERATION_ATOMIC_XOR, |
| IMAGE_OPERATION_ATOMIC_EXCHANGE, |
| IMAGE_OPERATION_ATOMIC_COMP_SWAP, |
| |
| IMAGE_OPERATION_LAST |
| }; |
| |
| static const glu::ShaderType s_shaders[] = {glu::SHADERTYPE_VERTEX, |
| glu::SHADERTYPE_FRAGMENT, |
| glu::SHADERTYPE_GEOMETRY, |
| glu::SHADERTYPE_TESSELLATION_CONTROL, |
| glu::SHADERTYPE_TESSELLATION_EVALUATION, |
| glu::SHADERTYPE_COMPUTE}; |
| |
| std::string getShaderImageLayoutQualifier(const tcu::TextureFormat &format) |
| { |
| std::ostringstream qualifier; |
| |
| switch (format.order) |
| { |
| case tcu::TextureFormat::RGBA: |
| qualifier << "rgba"; |
| break; |
| case tcu::TextureFormat::R: |
| qualifier << "r"; |
| break; |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| switch (format.type) |
| { |
| case tcu::TextureFormat::FLOAT: |
| qualifier << "32f"; |
| break; |
| case tcu::TextureFormat::HALF_FLOAT: |
| qualifier << "16f"; |
| break; |
| case tcu::TextureFormat::UNORM_INT8: |
| qualifier << "8"; |
| break; |
| case tcu::TextureFormat::SNORM_INT8: |
| qualifier << "8_snorm"; |
| break; |
| case tcu::TextureFormat::SIGNED_INT32: |
| qualifier << "32i"; |
| break; |
| case tcu::TextureFormat::SIGNED_INT16: |
| qualifier << "16i"; |
| break; |
| case tcu::TextureFormat::SIGNED_INT8: |
| qualifier << "8i"; |
| break; |
| case tcu::TextureFormat::UNSIGNED_INT32: |
| qualifier << "32ui"; |
| break; |
| case tcu::TextureFormat::UNSIGNED_INT16: |
| qualifier << "16ui"; |
| break; |
| case tcu::TextureFormat::UNSIGNED_INT8: |
| qualifier << "8ui"; |
| break; |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| return qualifier.str(); |
| } |
| |
| std::string getShaderImageTypeDeclaration(const tcu::TextureFormat &format, glu::TextureTestUtil::TextureType imageType) |
| { |
| std::ostringstream declaration; |
| |
| switch (format.type) |
| { |
| case tcu::TextureFormat::FLOAT: |
| case tcu::TextureFormat::HALF_FLOAT: |
| case tcu::TextureFormat::UNORM_INT8: |
| case tcu::TextureFormat::SNORM_INT8: |
| declaration << ""; |
| break; |
| |
| case tcu::TextureFormat::SIGNED_INT32: |
| case tcu::TextureFormat::SIGNED_INT16: |
| case tcu::TextureFormat::SIGNED_INT8: |
| declaration << "i"; |
| break; |
| |
| case tcu::TextureFormat::UNSIGNED_INT32: |
| case tcu::TextureFormat::UNSIGNED_INT16: |
| case tcu::TextureFormat::UNSIGNED_INT8: |
| declaration << "u"; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| declaration << "image"; |
| |
| switch (imageType) |
| { |
| case glu::TextureTestUtil::TEXTURETYPE_2D: |
| declaration << "2D"; |
| break; |
| case glu::TextureTestUtil::TEXTURETYPE_3D: |
| declaration << "3D"; |
| break; |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE: |
| declaration << "Cube"; |
| break; |
| case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY: |
| declaration << "2DArray"; |
| break; |
| case glu::TextureTestUtil::TEXTURETYPE_BUFFER: |
| declaration << "Buffer"; |
| break; |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: |
| declaration << "CubeArray"; |
| break; |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| return declaration.str(); |
| } |
| |
| std::string getShaderImageTypeExtensionString(glu::TextureTestUtil::TextureType imageType) |
| { |
| std::string extension; |
| |
| switch (imageType) |
| { |
| case glu::TextureTestUtil::TEXTURETYPE_2D: |
| case glu::TextureTestUtil::TEXTURETYPE_3D: |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE: |
| case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY: |
| extension = ""; |
| break; |
| |
| case glu::TextureTestUtil::TEXTURETYPE_BUFFER: |
| extension = "#extension GL_EXT_texture_buffer : enable"; |
| break; |
| |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: |
| extension = "#extension GL_EXT_texture_cube_map_array : enable"; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| return extension; |
| } |
| |
| std::string getShaderImageParamP(glu::TextureTestUtil::TextureType imageType) |
| { |
| switch (imageType) |
| { |
| case glu::TextureTestUtil::TEXTURETYPE_2D: |
| return "ivec2(1, 1)"; |
| |
| case glu::TextureTestUtil::TEXTURETYPE_3D: |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE: |
| case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY: |
| case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: |
| return "ivec3(1, 1, 1)"; |
| |
| case glu::TextureTestUtil::TEXTURETYPE_BUFFER: |
| return "1"; |
| |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| } |
| |
| std::string getOtherFunctionArguments(const tcu::TextureFormat &format, ImageOperation function) |
| { |
| std::ostringstream data; |
| data << ", "; |
| |
| bool isFloat = false; |
| |
| switch (format.type) |
| { |
| case tcu::TextureFormat::FLOAT: |
| case tcu::TextureFormat::HALF_FLOAT: |
| case tcu::TextureFormat::UNORM_INT8: |
| case tcu::TextureFormat::SNORM_INT8: |
| data << ""; |
| isFloat = true; |
| break; |
| |
| case tcu::TextureFormat::SIGNED_INT32: |
| case tcu::TextureFormat::SIGNED_INT16: |
| case tcu::TextureFormat::SIGNED_INT8: |
| data << "i"; |
| break; |
| |
| case tcu::TextureFormat::UNSIGNED_INT32: |
| case tcu::TextureFormat::UNSIGNED_INT16: |
| case tcu::TextureFormat::UNSIGNED_INT8: |
| data << "u"; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| |
| switch (function) |
| { |
| case IMAGE_OPERATION_LOAD: |
| return ""; |
| |
| case IMAGE_OPERATION_STORE: |
| data << "vec4(1, 1, 1, 1)"; |
| break; |
| |
| case IMAGE_OPERATION_ATOMIC_ADD: |
| case IMAGE_OPERATION_ATOMIC_MIN: |
| case IMAGE_OPERATION_ATOMIC_MAX: |
| case IMAGE_OPERATION_ATOMIC_AND: |
| case IMAGE_OPERATION_ATOMIC_OR: |
| case IMAGE_OPERATION_ATOMIC_XOR: |
| return ", 1"; |
| |
| case IMAGE_OPERATION_ATOMIC_EXCHANGE: |
| return isFloat ? ", 1.0" : ", 1"; |
| |
| case IMAGE_OPERATION_ATOMIC_COMP_SWAP: |
| return ", 1, 1"; |
| |
| default: |
| DE_ASSERT(false); |
| return std::string(""); |
| } |
| return data.str(); |
| } |
| |
| std::string getMemoryQualifier(MemoryQualifier memory) |
| { |
| switch (memory) |
| { |
| case MEMORY_NONE: |
| return std::string(""); |
| |
| case MEMORY_WRITEONLY: |
| return std::string("writeonly"); |
| |
| case MEMORY_READONLY: |
| return std::string("readonly"); |
| |
| case MEMORY_BOTH: |
| return std::string("writeonly readonly"); |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| return std::string(""); |
| } |
| |
| std::string getShaderImageFunctionExtensionString(ImageOperation function) |
| { |
| switch (function) |
| { |
| case IMAGE_OPERATION_STORE: |
| case IMAGE_OPERATION_LOAD: |
| return std::string(""); |
| |
| case IMAGE_OPERATION_ATOMIC_ADD: |
| case IMAGE_OPERATION_ATOMIC_MIN: |
| case IMAGE_OPERATION_ATOMIC_MAX: |
| case IMAGE_OPERATION_ATOMIC_AND: |
| case IMAGE_OPERATION_ATOMIC_OR: |
| case IMAGE_OPERATION_ATOMIC_XOR: |
| case IMAGE_OPERATION_ATOMIC_EXCHANGE: |
| case IMAGE_OPERATION_ATOMIC_COMP_SWAP: |
| return std::string("#extension GL_OES_shader_image_atomic : enable"); |
| |
| default: |
| DE_ASSERT(false); |
| } |
| return std::string(""); |
| } |
| |
| std::string getFunctionName(ImageOperation function) |
| { |
| switch (function) |
| { |
| case IMAGE_OPERATION_STORE: |
| return std::string("imageStore"); |
| case IMAGE_OPERATION_LOAD: |
| return std::string("imageLoad"); |
| case IMAGE_OPERATION_ATOMIC_ADD: |
| return std::string("imageAtomicAdd"); |
| case IMAGE_OPERATION_ATOMIC_MIN: |
| return std::string("imageAtomicMin"); |
| case IMAGE_OPERATION_ATOMIC_MAX: |
| return std::string("imageAtomicMax"); |
| case IMAGE_OPERATION_ATOMIC_AND: |
| return std::string("imageAtomicAnd"); |
| case IMAGE_OPERATION_ATOMIC_OR: |
| return std::string("imageAtomicOr"); |
| case IMAGE_OPERATION_ATOMIC_XOR: |
| return std::string("imageAtomicXor"); |
| case IMAGE_OPERATION_ATOMIC_EXCHANGE: |
| return std::string("imageAtomicExchange"); |
| case IMAGE_OPERATION_ATOMIC_COMP_SWAP: |
| return std::string("imageAtomicCompSwap"); |
| default: |
| DE_ASSERT(false); |
| } |
| return std::string(""); |
| } |
| |
| std::string generateShaderSource(ImageOperation function, MemoryQualifier memory, |
| glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat &format, |
| glu::ShaderType shaderType) |
| { |
| const char *shaderTemplate = |
| "${GLSL_VERSION_DECL}\n" |
| "${GLSL_TYPE_EXTENSION}\n" |
| "${GLSL_FUNCTION_EXTENSION}\n" |
| "${GEOMETRY_SHADER_LAYOUT}\n" |
| "layout(${LAYOUT_FORMAT}, binding = 0) highp uniform ${MEMORY_QUALIFIER} ${IMAGE_TYPE} u_img0;\n" |
| "void main(void)\n" |
| "{\n" |
| " ${FUNCTION_NAME}(u_img0, ${IMAGE_PARAM_P}${FUNCTION_ARGUMENTS});\n" |
| "}\n"; |
| |
| std::map<std::string, std::string> params; |
| |
| params["GLSL_VERSION_DECL"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); |
| params["GLSL_TYPE_EXTENSION"] = getShaderImageTypeExtensionString(imageType); |
| params["GLSL_FUNCTION_EXTENSION"] = getShaderImageFunctionExtensionString(function); |
| params["GEOMETRY_SHADER_LAYOUT"] = |
| getGLShaderType(shaderType) == GL_GEOMETRY_SHADER ? "layout(max_vertices = 3) out;" : ""; |
| params["LAYOUT_FORMAT"] = getShaderImageLayoutQualifier(format); |
| params["MEMORY_QUALIFIER"] = getMemoryQualifier(memory); |
| params["IMAGE_TYPE"] = getShaderImageTypeDeclaration(format, imageType); |
| params["FUNCTION_NAME"] = getFunctionName(function); |
| params["IMAGE_PARAM_P"] = getShaderImageParamP(imageType); |
| params["FUNCTION_ARGUMENTS"] = getOtherFunctionArguments(format, function); |
| |
| return tcu::StringTemplate(shaderTemplate).specialize(params); |
| } |
| |
| void testShader(NegativeTestContext &ctx, ImageOperation function, MemoryQualifier memory, |
| glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat &format) |
| { |
| tcu::TestLog &log = ctx.getLog(); |
| ctx.beginSection(getFunctionName(function) + " " + getMemoryQualifier(memory) + " " + |
| getShaderImageLayoutQualifier(format)); |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaders); ndx++) |
| { |
| if (ctx.isShaderSupported(s_shaders[ndx])) |
| { |
| ctx.beginSection(std::string("Verify shader: ") + glu::getShaderTypeName(s_shaders[ndx])); |
| std::string shaderSource(generateShaderSource(function, memory, imageType, format, s_shaders[ndx])); |
| const glu::ShaderProgram program(ctx.getRenderContext(), |
| glu::ProgramSources() << glu::ShaderSource(s_shaders[ndx], shaderSource)); |
| if (program.getShaderInfo(s_shaders[ndx]).compileOk) |
| { |
| log << program; |
| log << tcu::TestLog::Message << "Expected program to fail, but compilation passed." |
| << tcu::TestLog::EndMessage; |
| ctx.fail("Shader was not expected to compile."); |
| } |
| ctx.endSection(); |
| } |
| } |
| ctx.endSection(); |
| } |
| |
| void image_store(NegativeTestContext &ctx, glu::TextureTestUtil::TextureType imageType) |
| { |
| const tcu::TextureFormat formats[] = { |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)}; |
| |
| const MemoryQualifier memoryOptions[] = {MEMORY_READONLY, MEMORY_BOTH}; |
| |
| ctx.beginSection("It is an error to pass a readonly image to imageStore."); |
| for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) |
| { |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) |
| { |
| testShader(ctx, IMAGE_OPERATION_STORE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]); |
| } |
| } |
| ctx.endSection(); |
| } |
| |
| void image_load(NegativeTestContext &ctx, glu::TextureTestUtil::TextureType imageType) |
| { |
| const tcu::TextureFormat formats[] = { |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)}; |
| |
| const MemoryQualifier memoryOptions[] = {MEMORY_WRITEONLY, MEMORY_BOTH}; |
| |
| ctx.beginSection("It is an error to pass a writeonly image to imageLoad."); |
| for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) |
| { |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) |
| { |
| testShader(ctx, IMAGE_OPERATION_LOAD, memoryOptions[memoryNdx], imageType, formats[fmtNdx]); |
| } |
| } |
| ctx.endSection(); |
| } |
| |
| void image_atomic(NegativeTestContext &ctx, glu::TextureTestUtil::TextureType imageType) |
| { |
| const tcu::TextureFormat formats[] = { |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)}; |
| |
| const MemoryQualifier memoryOptions[] = {MEMORY_READONLY, MEMORY_WRITEONLY, MEMORY_BOTH}; |
| |
| const ImageOperation imageOperations[] = {IMAGE_OPERATION_ATOMIC_ADD, IMAGE_OPERATION_ATOMIC_MIN, |
| IMAGE_OPERATION_ATOMIC_MAX, IMAGE_OPERATION_ATOMIC_AND, |
| IMAGE_OPERATION_ATOMIC_OR, IMAGE_OPERATION_ATOMIC_XOR, |
| IMAGE_OPERATION_ATOMIC_COMP_SWAP}; |
| |
| ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*."); |
| for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) |
| { |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) |
| { |
| for (int functionNdx = 0; functionNdx < DE_LENGTH_OF_ARRAY(imageOperations); ++functionNdx) |
| { |
| testShader(ctx, imageOperations[functionNdx], memoryOptions[memoryNdx], imageType, formats[fmtNdx]); |
| } |
| } |
| } |
| ctx.endSection(); |
| } |
| |
| void image_atomic_exchange(NegativeTestContext &ctx, glu::TextureTestUtil::TextureType imageType) |
| { |
| const tcu::TextureFormat formats[] = { |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), |
| |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), |
| tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), |
| tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)}; |
| |
| const MemoryQualifier memoryOptions[] = {MEMORY_READONLY, MEMORY_WRITEONLY, MEMORY_BOTH}; |
| |
| ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*."); |
| for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) |
| { |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) |
| { |
| testShader(ctx, IMAGE_OPERATION_ATOMIC_EXCHANGE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]); |
| } |
| } |
| ctx.endSection(); |
| } |
| |
| // Re-routing function template for generating the standard negative |
| // test function signature with texture type added. |
| |
| template <int Type> |
| void loadFuncWrapper(NegativeTestContext &ctx) |
| { |
| image_load(ctx, (glu::TextureTestUtil::TextureType)Type); |
| } |
| |
| template <int Type> |
| void storeFuncWrapper(NegativeTestContext &ctx) |
| { |
| image_store(ctx, (glu::TextureTestUtil::TextureType)Type); |
| } |
| |
| template <int Type> |
| void atomicFuncWrapper(NegativeTestContext &ctx) |
| { |
| image_atomic(ctx, (glu::TextureTestUtil::TextureType)Type); |
| } |
| |
| template <int Type> |
| void atomicExchangeFuncWrapper(NegativeTestContext &ctx) |
| { |
| image_atomic_exchange(ctx, (glu::TextureTestUtil::TextureType)Type); |
| } |
| |
| } // namespace |
| |
| // Set of texture types to create tests for. |
| #define CREATE_TEST_FUNC_PER_TEXTURE_TYPE(NAME, FUNC) \ |
| const FunctionContainer NAME[] = { \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_2D>, "texture_2d", "Texture2D negative tests."}, \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_3D>, "texture_3d", "Texture3D negative tests."}, \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE>, "cube", "Cube texture negative tests."}, \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY>, "2d_array", "2D array texture negative tests."}, \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_BUFFER>, "buffer", "Buffer negative tests."}, \ |
| {FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY>, "cube_array", "Cube array texture negative tests."}} |
| |
| std::vector<FunctionContainer> getNegativeShaderImageLoadTestFunctions(void) |
| { |
| CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, loadFuncWrapper); |
| return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); |
| } |
| |
| std::vector<FunctionContainer> getNegativeShaderImageStoreTestFunctions(void) |
| { |
| CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, storeFuncWrapper); |
| return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); |
| } |
| |
| std::vector<FunctionContainer> getNegativeShaderImageAtomicTestFunctions(void) |
| { |
| CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicFuncWrapper); |
| return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); |
| } |
| |
| std::vector<FunctionContainer> getNegativeShaderImageAtomicExchangeTestFunctions(void) |
| { |
| CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicExchangeFuncWrapper); |
| return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); |
| } |
| |
| } // namespace NegativeTestShared |
| } // namespace Functional |
| } // namespace gles31 |
| } // namespace deqp |
