external/vulkancts/modules/vulkan/image/vktImageMismatchedFormatsTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2020 The Khronos Group Inc.
   6  * Copyright (c) 2016 The Android Open Source Project
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Testing writing and reading for mismatched formats
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktImageLoadStoreTests.hpp"
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktImageTestsUtil.hpp"
  28 #include "vktImageLoadStoreUtil.hpp"
  29 #include "vktImageTexture.hpp"
  30
  31 #include "vkDefs.hpp"
  32 #include "vkRef.hpp"
  33 #include "vkRefUtil.hpp"
  34 #include "vkPlatform.hpp"
  35 #include "vkPrograms.hpp"
  36 #include "vkMemUtil.hpp"
  37 #include "vkBarrierUtil.hpp"
  38 #include "vkBuilderUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkImageUtil.hpp"
  41 #include "vkCmdUtil.hpp"
  42 #include "vkObjUtil.hpp"
  43 #include "vkImageWithMemory.hpp"
  44
  45 #include "deMath.h"
  46 #include "deUniquePtr.hpp"
  47 #include "deSharedPtr.hpp"
  48 #include "deStringUtil.hpp"
  49
  50 #include "tcuImageCompare.hpp"
  51 #include "tcuTexture.hpp"
  52 #include "tcuTextureUtil.hpp"
  53 #include "tcuFloat.hpp"
  54 #include "tcuStringTemplate.hpp"
  55
  56 #include <string>
  57 #include <vector>
  58 #include <map>
  59
  60 using namespace vk;
  61
  62 namespace vkt
  63 {
  64 namespace image
  65 {
  66 namespace
  67 {
  68
  69 struct FormatInfo
  70 {
  71         const char* GLSLFormat;
  72         int VectorWidth;
  73         int BytesPerPixel;
  74         tcu::TextureChannelClass ChannelClass;
  75 };
  76
  77 FormatInfo getFormatInfo (VkFormat format)
  78 {
  79         FormatInfo result;
  80
  81         const tcu::TextureFormat texFormat = mapVkFormat(format);
  82
  83         result.VectorWidth = getNumUsedChannels(texFormat.order);
  84         result.BytesPerPixel = getPixelSize(texFormat);
  85         result.ChannelClass = tcu::getTextureChannelClass(texFormat.type);
  86
  87         return result;
  88 }
  89
  90 std::string ChannelClassToImageType (tcu::TextureChannelClass channelClass)
  91 {
  92         switch (channelClass)
  93         {
  94                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uimage2D";
  95                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "iimage2D";
  96                 default: return "image2D";
  97         }
  98 }
  99
 100 std::string ChannelClassToVecType (tcu::TextureChannelClass channelClass)
 101 {
 102         switch (channelClass)
 103         {
 104                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4";
 105                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4";
 106                 default: return "vec4";
 107         }
 108 }
 109
 110 std::string ChannelClassToDefaultVecValue (tcu::TextureChannelClass channelClass)
 111 {
 112         switch (channelClass)
 113         {
 114                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4(1, 10, 100, 1000)";
 115                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4(-1, 2, -1000, 2000)";
 116                 default: return "vec4(0.25, 0.5, 0.0, 1.0)";
 117         }
 118 }
 119
 120 const std::map<std::string, FormatInfo> SpirvFormats {
 121         { "Rgba32f",            { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 122         { "Rg32f",                      { nullptr,                      2, 8,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 123         { "R32f",                       { nullptr,                      1, 4,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 124         { "Rgba16f",            { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 125         { "Rg16f",                      { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 126         { "R16f",                       { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 127         { "Rgba16",                     { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 128         { "Rg16",                       { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 129         { "R16",                        { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 130         { "Rgba16Snorm",        { "rgba16_snorm",       4, 8,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 131         { "Rg16Snorm",          { "rg16_snorm",         2, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 132         { "R16Snorm",           { "r16_snorm",          1, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 133         { "Rgb10A2",            { "rgb10_a2",           4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 134         { "R11fG11fB10f",       { "r11f_g11f_b10f", 3, 4,               tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 135         { "Rgba8",                      { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 136         { "Rg8",                        { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 137         { "R8",                         { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 138         { "Rgba8Snorm",         { "rgba8_snorm",        4, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 139         { "Rg8Snorm",           { "rg8_snorm",          2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 140         { "R8Snorm",            { "r8_snorm",           1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 141         { "Rgba32i",            { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 142         { "Rg32i",                      { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 143         { "R32i",                       { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 144         { "Rgba16i",            { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 145         { "Rg16i",                      { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 146         { "R16i",                       { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 147         { "Rgba8i",                     { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 148         { "Rg8i",                       { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 149         { "R8i",                        { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 150         { "Rgba32ui",           { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 151         { "Rg32ui",                     { nullptr,                      2, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 152         { "R32ui",                      { nullptr,                      1, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 153         { "Rgba16ui",           { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 154         { "Rg16ui",                     { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 155         { "R16ui",                      { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 156         { "Rgb10a2ui",          { "rgb10_a2ui",         4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 157         { "Rgba8ui",            { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 158         { "Rg8ui",                      { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 159         { "R8ui",                       { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } }
 160 };
 161
 162 FormatInfo getFormatInfo (const std::string& spirvFormat)
 163 {
 164         auto it = SpirvFormats.find(spirvFormat);
 165         if (it != SpirvFormats.end()) return it->second;
 166         else return {"", 0, 0, tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT};
 167 }
 168
 169 bool matching (VkFormat format, const std::string& spirvFormat)
 170 {
 171         try
 172         {
 173                 FormatInfo      baseFormat              =       getFormatInfo(format);
 174                 FormatInfo      shaderFormat    =       getFormatInfo(spirvFormat);
 175
 176                 return (baseFormat.VectorWidth == shaderFormat.VectorWidth &&
 177                                 baseFormat.BytesPerPixel == shaderFormat.BytesPerPixel &&
 178                                 baseFormat.ChannelClass == shaderFormat.ChannelClass);
 179         }
 180         catch (const tcu::InternalError&)
 181         {
 182                 return false;
 183         }
 184 }
 185
 186 enum class TestType
 187 {
 188         READ = 0,
 189         SPARSE_READ,
 190         WRITE
 191 };
 192
 193 class MismatchedFormatTest : public TestCase
 194 {
 195 public:
 196                                                 MismatchedFormatTest (tcu::TestContext&         testCtx,
 197                                                                                           const std::string&    name,
 198                                                                                           const std::string&    description,
 199                                                                                           const TestType                type,
 200                                                                                           const VkFormat                format,
 201                                                                                           const std::string&    spirvFormat);
 202
 203         virtual void            checkSupport            (Context&                       context) const;
 204         void                            initPrograms            (SourceCollections&     programCollection) const;
 205         TestInstance*           createInstance          (Context&                       context) const;
 206
 207 private:
 208         const TestType          m_type;
 209         const VkFormat          m_format;
 210         const std::string       m_spirvFormat;
 211 };
 212
 213 MismatchedFormatTest::MismatchedFormatTest (tcu::TestContext&   testCtx,
 214                                                                                         const std::string&      name,
 215                                                                                         const std::string&      description,
 216                                                                                         const TestType          type,
 217                                                                                         const VkFormat          format,
 218                                                                                         const std::string&      spirvFormat)
 219         : TestCase                                              (testCtx, name, description)
 220         , m_type                                                (type)
 221         , m_format                                              (format)
 222         , m_spirvFormat                                 (spirvFormat)
 223 {
 224 }
 225
 226 void MismatchedFormatTest::checkSupport (Context& context) const
 227 {
 228         if (m_type == TestType::SPARSE_READ)
 229         {
 230                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
 231
 232                 if (!getPhysicalDeviceFeatures(context.getInstanceInterface(), context.getPhysicalDevice()).sparseResidencyBuffer)
 233                 {
 234                         TCU_THROW(NotSupportedError, "Sparse partially resident buffers not supported");
 235                 }
 236
 237                 if (!getPhysicalDeviceFeatures(context.getInstanceInterface(), context.getPhysicalDevice()).shaderResourceResidency)
 238                 {
 239                         TCU_THROW(NotSupportedError, "Shader resource residency not supported");
 240                 }
 241         }
 242
 243         VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), m_format);
 244
 245         if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) == 0)
 246         {
 247                 TCU_THROW(NotSupportedError, "Creating storage image with this format is not supported");
 248         }
 249 }
 250
 251 void MismatchedFormatTest::initPrograms (SourceCollections& programCollection) const
 252 {
 253         std::string     source;
 254
 255         if (m_type == TestType::READ)
 256         {
 257                 source = R"(
 258                         #version 460 core
 259
 260                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 261
 262                         void main()
 263                         {
 264                                 ${VECT} value = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy));
 265                         }
 266                 )";
 267         }
 268         else if (m_type == TestType::WRITE)
 269         {
 270                 source = R"(
 271                         #version 460 core
 272
 273                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 274
 275                         void main()
 276                         {
 277                                 imageStore(inputImage, ivec2(gl_GlobalInvocationID.xy), ${VALUE});
 278                         }
 279                 )";
 280         }
 281         else if (m_type == TestType::SPARSE_READ)
 282         {
 283                 source = R"(
 284                         #version 460 core
 285                         #extension GL_ARB_sparse_texture2 : require
 286
 287                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 288
 289                         void main()
 290                         {
 291                                 ${VECT} result;
 292                                 int r = sparseImageLoadARB(inputImage, ivec2(gl_GlobalInvocationID.xy), result);
 293                         }
 294                 )";
 295         }
 296
 297         const FormatInfo        spirvFormatInfo         =       getFormatInfo(m_spirvFormat);
 298
 299         const std::string       glslFormat                      =       spirvFormatInfo.GLSLFormat ?
 300                                                                                                 spirvFormatInfo.GLSLFormat : de::toLower(m_spirvFormat);
 301
 302         std::map<std::string, std::string>                      specializations;
 303
 304         specializations["FORMAT"]                               =       glslFormat;
 305         specializations["VECT"]                                 =       ChannelClassToVecType(spirvFormatInfo.ChannelClass);
 306         specializations["IMAGE"]                                =       ChannelClassToImageType(spirvFormatInfo.ChannelClass);
 307         specializations["VALUE"]                                =       ChannelClassToDefaultVecValue(spirvFormatInfo.ChannelClass);
 308
 309         programCollection.glslSources.add("comp") << glu::ComputeSource( tcu::StringTemplate{source}.specialize(specializations) );
 310 }
 311
 312 class MismatchedFormatTestInstance : public TestInstance
 313 {
 314 public:
 315                                                 MismatchedFormatTestInstance (Context&                          context,
 316                                                                                                           const TestType                type,
 317                                                                                                           const VkFormat                format,
 318                                                                                                           const std::string&    spirvFormat);
 319
 320         tcu::TestStatus         iterate                                 (void);
 321
 322 protected:
 323         const TestType          m_type;
 324         const VkFormat          m_format;
 325         const std::string       m_spirvFormat;
 326
 327 };
 328
 329 MismatchedFormatTestInstance::MismatchedFormatTestInstance (Context& context, const TestType type, const VkFormat format, const std::string& spirvFormat)
 330         : TestInstance          (context)
 331         , m_type                        (type)
 332         , m_format                      (format)
 333         , m_spirvFormat         (spirvFormat)
 334 {
 335 }
 336
 337 tcu::TestStatus MismatchedFormatTestInstance::iterate (void)
 338 {
 339         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
 340         const VkDevice                                  device                          = m_context.getDevice();
 341         const VkQueue                                   queue                           = m_context.getUniversalQueue();
 342         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 343
 344         Move<VkShaderModule>                    shaderModule            = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0);
 345
 346         Move<VkDescriptorSetLayout>             descriptorSetLayout     = DescriptorSetLayoutBuilder()
 347                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 348                                                                                                                         .build(vk, device);
 349         Move<VkDescriptorPool>                  descriptorPool          = DescriptorPoolBuilder()
 350                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
 351                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
 352
 353         Move<VkDescriptorSet>                   descriptorSet           = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 354         Move<VkPipelineLayout>                  pipelineLayout          = makePipelineLayout(vk, device, descriptorSetLayout.get());
 355
 356         Move<VkPipeline>                                pipeline                        = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule);
 357
 358         VkImageCreateFlags                              imageFlag                       = m_type == TestType::SPARSE_READ ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0u;
 359
 360         const VkImageCreateInfo                 imageCreateInfo         =
 361         {
 362                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                                                                            // VkStructureType                      sType;
 363                 DE_NULL,                                                                                                                                                                                        // const void*                          pNext;
 364                 imageFlag,                                                                                                                                                                                      // VkImageCreateFlags           flags;
 365                 VK_IMAGE_TYPE_2D,                                                                                                                                                                       // VkImageType                          imageType;
 366                 m_format,                                                                                                                                                                                       // VkFormat                                     format;
 367                 makeExtent3D(8, 8, 1),                                                                                                                                                          // VkExtent3D                           extent;
 368                 1u,                                                                                                                                                                                                     // deUint32                                     mipLevels;
 369                 1u,                                                                                                                                                                                                     // deUint32                                     arrayLayers;
 370                 VK_SAMPLE_COUNT_1_BIT,                                                                                                                                                          // VkSampleCountFlagBits        samples;
 371                 VK_IMAGE_TILING_OPTIMAL,                                                                                                                                                        // VkImageTiling                        tiling;
 372                 VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,         // VkImageUsageFlags            usage;
 373                 VK_SHARING_MODE_EXCLUSIVE,                                                                                                                                                      // VkSharingMode                        sharingMode;
 374                 0u,                                                                                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 375                 DE_NULL,                                                                                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 376                 VK_IMAGE_LAYOUT_UNDEFINED                                                                                                                                                       // VkImageLayout                        initialLayout;
 377         };
 378
 379         vk::Move<vk::VkImage>                   storageImage            = createImage(vk, device, &imageCreateInfo);
 380
 381         de::MovePtr<vk::Allocation>                                     storageAllocation;
 382         vk::Move<vk::VkSemaphore>                                       bindSemaphore;
 383         std::vector<de::SharedPtr<Allocation> >         allocations;
 384
 385         if (m_type == TestType::SPARSE_READ)
 386         {
 387                 bindSemaphore = createSemaphore(m_context.getDeviceInterface(), m_context.getDevice());
 388
 389                 allocateAndBindSparseImage(     vk, device, m_context.getPhysicalDevice(), m_context.getInstanceInterface(),
 390                                                                         imageCreateInfo, *bindSemaphore, m_context.getSparseQueue(),
 391                                                                         m_context.getDefaultAllocator(), allocations, mapVkFormat(m_format), *storageImage      );
 392         }
 393         else
 394         {
 395                 storageAllocation = m_context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, device, *storageImage), MemoryRequirement::Any);
 396                 VK_CHECK(vk.bindImageMemory(device, *storageImage, storageAllocation->getMemory(), storageAllocation->getOffset()));
 397         }
 398
 399         Move<VkImageView>                               storageImageView        = makeImageView(vk, device, *storageImage, VK_IMAGE_VIEW_TYPE_2D, m_format, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
 400         VkDescriptorImageInfo                   storageImageInfo        = makeDescriptorImageInfo(DE_NULL, *storageImageView, VK_IMAGE_LAYOUT_GENERAL);
 401
 402         DescriptorSetUpdateBuilder              builder;
 403         builder
 404                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storageImageInfo)
 405                 .update(vk, device);
 406
 407         Move<VkCommandPool>                             cmdPool                         = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
 408         Move<VkCommandBuffer>                   cmdBuffer                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 409
 410         beginCommandBuffer(vk, *cmdBuffer);
 411                 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 412                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 413                 vk.cmdDispatch(*cmdBuffer, 8, 8, 1);
 414         endCommandBuffer(vk, *cmdBuffer);
 415
 416         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 417
 418         return tcu::TestStatus::pass("Passed");
 419 }
 420
 421 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
 422 {
 423         return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
 424 }
 425
 426 } // anonymous ns
 427
 428 tcu::TestCaseGroup* createImageMismatchedFormatsTests (tcu::TestContext& testCtx)
 429 {
 430         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mismatched_formats", "Test image load/store operations on mismatched formats"));
 431         de::MovePtr<tcu::TestCaseGroup> testGroupOpRead(new tcu::TestCaseGroup(testCtx, "image_read", "perform OpImageRead"));
 432         de::MovePtr<tcu::TestCaseGroup> testGroupOpWrite(new tcu::TestCaseGroup(testCtx, "image_write", "perform OpImageWrite"));
 433         de::MovePtr<tcu::TestCaseGroup> testGroupOpSparseRead(new tcu::TestCaseGroup(testCtx, "sparse_image_read", "perform OpSparseImageRead"));
 434
 435         for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8; format < VK_CORE_FORMAT_LAST; format = static_cast<VkFormat>(format+1))
 436         {
 437                 for (auto& pair : SpirvFormats)
 438                 {
 439                         const std::string&      spirvFormat = pair.first;
 440
 441                         if (matching(format, spirvFormat))
 442                         {
 443                                 const std::string       enumName        = getFormatName(format);
 444                                 const std::string       testName        = de::toLower( enumName.substr(10) + "_with_" + spirvFormat );
 445
 446                                 testGroupOpRead->addChild(new MismatchedFormatTest(     testCtx, testName, "",
 447                                                                                                                                         TestType::READ,
 448                                                                                                                                         format, spirvFormat) );
 449
 450                                 testGroupOpWrite->addChild(new MismatchedFormatTest(testCtx, testName, "",
 451                                                                                                                                         TestType::WRITE,
 452                                                                                                                                         format, spirvFormat) );
 453
 454                                 testGroupOpSparseRead->addChild(new MismatchedFormatTest(       testCtx, testName, "",
 455                                                                                                                                                         TestType::SPARSE_READ,
 456                                                                                                                                                         format, spirvFormat) );
 457                         }
 458                 }
 459         }
 460
 461         testGroup->addChild(testGroupOpRead.release());
 462         testGroup->addChild(testGroupOpWrite.release());
 463         testGroup->addChild(testGroupOpSparseRead.release());
 464
 465         return testGroup.release();
 466 }
 467
 468 } // image
 469 } // vkt