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
 238         VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), m_format);
 239
 240         if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) == 0)
 241         {
 242                 TCU_THROW(NotSupportedError, "Creating storage image with this format is not supported");
 243         }
 244 }
 245
 246 void MismatchedFormatTest::initPrograms (SourceCollections& programCollection) const
 247 {
 248         std::string     source;
 249
 250         if (m_type == TestType::READ)
 251         {
 252                 source = R"(
 253                         #version 460 core
 254
 255                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 256
 257                         void main()
 258                         {
 259                                 ${VECT} value = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy));
 260                         }
 261                 )";
 262         }
 263         else if (m_type == TestType::WRITE)
 264         {
 265                 source = R"(
 266                         #version 460 core
 267
 268                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 269
 270                         void main()
 271                         {
 272                                 imageStore(inputImage, ivec2(gl_GlobalInvocationID.xy), ${VALUE});
 273                         }
 274                 )";
 275         }
 276         else if (m_type == TestType::SPARSE_READ)
 277         {
 278                 source = R"(
 279                         #version 460 core
 280                         #extension GL_ARB_sparse_texture2 : require
 281
 282                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 283
 284                         void main()
 285                         {
 286                                 ${VECT} result;
 287                                 int r = sparseImageLoadARB(inputImage, ivec2(gl_GlobalInvocationID.xy), result);
 288                         }
 289                 )";
 290         }
 291
 292         const FormatInfo        spirvFormatInfo         =       getFormatInfo(m_spirvFormat);
 293
 294         const std::string       glslFormat                      =       spirvFormatInfo.GLSLFormat ?
 295                                                                                                 spirvFormatInfo.GLSLFormat : de::toLower(m_spirvFormat);
 296
 297         std::map<std::string, std::string>                      specializations;
 298
 299         specializations["FORMAT"]                               =       glslFormat;
 300         specializations["VECT"]                                 =       ChannelClassToVecType(spirvFormatInfo.ChannelClass);
 301         specializations["IMAGE"]                                =       ChannelClassToImageType(spirvFormatInfo.ChannelClass);
 302         specializations["VALUE"]                                =       ChannelClassToDefaultVecValue(spirvFormatInfo.ChannelClass);
 303
 304         programCollection.glslSources.add("comp") << glu::ComputeSource( tcu::StringTemplate{source}.specialize(specializations) );
 305 }
 306
 307 class MismatchedFormatTestInstance : public TestInstance
 308 {
 309 public:
 310                                                 MismatchedFormatTestInstance (Context&                          context,
 311                                                                                                           const TestType                type,
 312                                                                                                           const VkFormat                format,
 313                                                                                                           const std::string&    spirvFormat);
 314
 315         tcu::TestStatus         iterate                                 (void);
 316
 317 protected:
 318         const TestType          m_type;
 319         const VkFormat          m_format;
 320         const std::string       m_spirvFormat;
 321
 322 };
 323
 324 MismatchedFormatTestInstance::MismatchedFormatTestInstance (Context& context, const TestType type, const VkFormat format, const std::string& spirvFormat)
 325         : TestInstance          (context)
 326         , m_type                        (type)
 327         , m_format                      (format)
 328         , m_spirvFormat         (spirvFormat)
 329 {
 330 }
 331
 332 tcu::TestStatus MismatchedFormatTestInstance::iterate (void)
 333 {
 334         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
 335         const VkDevice                                  device                          = m_context.getDevice();
 336         const VkQueue                                   queue                           = m_context.getUniversalQueue();
 337         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 338
 339         Move<VkShaderModule>                    shaderModule            = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0);
 340
 341         Move<VkDescriptorSetLayout>             descriptorSetLayout     = DescriptorSetLayoutBuilder()
 342                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 343                                                                                                                         .build(vk, device);
 344         Move<VkDescriptorPool>                  descriptorPool          = DescriptorPoolBuilder()
 345                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
 346                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
 347
 348         Move<VkDescriptorSet>                   descriptorSet           = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 349         Move<VkPipelineLayout>                  pipelineLayout          = makePipelineLayout(vk, device, descriptorSetLayout.get());
 350
 351         Move<VkPipeline>                                pipeline                        = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule);
 352
 353         VkImageCreateFlags                              imageFlag                       = m_type == TestType::SPARSE_READ ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0u;
 354
 355         const VkImageCreateInfo                 imageCreateInfo         =
 356         {
 357                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                                                                            // VkStructureType                      sType;
 358                 DE_NULL,                                                                                                                                                                                        // const void*                          pNext;
 359                 imageFlag,                                                                                                                                                                                      // VkImageCreateFlags           flags;
 360                 VK_IMAGE_TYPE_2D,                                                                                                                                                                       // VkImageType                          imageType;
 361                 m_format,                                                                                                                                                                                       // VkFormat                                     format;
 362                 makeExtent3D(8, 8, 1),                                                                                                                                                          // VkExtent3D                           extent;
 363                 1u,                                                                                                                                                                                                     // deUint32                                     mipLevels;
 364                 1u,                                                                                                                                                                                                     // deUint32                                     arrayLayers;
 365                 VK_SAMPLE_COUNT_1_BIT,                                                                                                                                                          // VkSampleCountFlagBits        samples;
 366                 VK_IMAGE_TILING_OPTIMAL,                                                                                                                                                        // VkImageTiling                        tiling;
 367                 VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,         // VkImageUsageFlags            usage;
 368                 VK_SHARING_MODE_EXCLUSIVE,                                                                                                                                                      // VkSharingMode                        sharingMode;
 369                 0u,                                                                                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 370                 DE_NULL,                                                                                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 371                 VK_IMAGE_LAYOUT_UNDEFINED                                                                                                                                                       // VkImageLayout                        initialLayout;
 372         };
 373
 374         vk::Move<vk::VkImage>                   storageImage            = createImage(vk, device, &imageCreateInfo);
 375
 376         de::MovePtr<vk::Allocation>                                     storageAllocation;
 377         vk::Move<vk::VkSemaphore>                                       bindSemaphore;
 378         std::vector<de::SharedPtr<Allocation> >         allocations;
 379
 380         if (m_type == TestType::SPARSE_READ)
 381         {
 382                 bindSemaphore = createSemaphore(m_context.getDeviceInterface(), m_context.getDevice());
 383
 384                 allocateAndBindSparseImage(     vk, device, m_context.getPhysicalDevice(), m_context.getInstanceInterface(),
 385                                                                         imageCreateInfo, *bindSemaphore, m_context.getSparseQueue(),
 386                                                                         m_context.getDefaultAllocator(), allocations, mapVkFormat(m_format), *storageImage      );
 387         }
 388         else
 389         {
 390                 storageAllocation = m_context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, device, *storageImage), MemoryRequirement::Any);
 391                 VK_CHECK(vk.bindImageMemory(device, *storageImage, storageAllocation->getMemory(), storageAllocation->getOffset()));
 392         }
 393
 394         Move<VkImageView>                               storageImageView        = makeImageView(vk, device, *storageImage, VK_IMAGE_VIEW_TYPE_2D, m_format, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
 395         VkDescriptorImageInfo                   storageImageInfo        = makeDescriptorImageInfo(DE_NULL, *storageImageView, VK_IMAGE_LAYOUT_GENERAL);
 396
 397         DescriptorSetUpdateBuilder              builder;
 398         builder
 399                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storageImageInfo)
 400                 .update(vk, device);
 401
 402         Move<VkCommandPool>                             cmdPool                         = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
 403         Move<VkCommandBuffer>                   cmdBuffer                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 404
 405         beginCommandBuffer(vk, *cmdBuffer);
 406                 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 407                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 408                 vk.cmdDispatch(*cmdBuffer, 8, 8, 1);
 409         endCommandBuffer(vk, *cmdBuffer);
 410
 411         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 412
 413         return tcu::TestStatus::pass("Passed");
 414 }
 415
 416 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
 417 {
 418         return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
 419 }
 420
 421 } // anonymous ns
 422
 423 tcu::TestCaseGroup* createImageMismatchedFormatsTests (tcu::TestContext& testCtx)
 424 {
 425         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mismatched_formats", "Test image load/store operations on mismatched formats"));
 426         de::MovePtr<tcu::TestCaseGroup> testGroupOpRead(new tcu::TestCaseGroup(testCtx, "image_read", "perform OpImageRead"));
 427         de::MovePtr<tcu::TestCaseGroup> testGroupOpWrite(new tcu::TestCaseGroup(testCtx, "image_write", "perform OpImageWrite"));
 428         de::MovePtr<tcu::TestCaseGroup> testGroupOpSparseRead(new tcu::TestCaseGroup(testCtx, "sparse_image_read", "perform OpSparseImageRead"));
 429
 430         for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8; format < VK_CORE_FORMAT_LAST; format = static_cast<VkFormat>(format+1))
 431         {
 432                 for (auto& pair : SpirvFormats)
 433                 {
 434                         const std::string&      spirvFormat = pair.first;
 435
 436                         if (matching(format, spirvFormat))
 437                         {
 438                                 const std::string       enumName        = getFormatName(format);
 439                                 const std::string       testName        = de::toLower( enumName.substr(10) + "_with_" + spirvFormat );
 440
 441                                 testGroupOpRead->addChild(new MismatchedFormatTest(     testCtx, testName, "",
 442                                                                                                                                         TestType::READ,
 443                                                                                                                                         format, spirvFormat) );
 444
 445                                 testGroupOpWrite->addChild(new MismatchedFormatTest(testCtx, testName, "",
 446                                                                                                                                         TestType::WRITE,
 447                                                                                                                                         format, spirvFormat) );
 448
 449                                 testGroupOpSparseRead->addChild(new MismatchedFormatTest(       testCtx, testName, "",
 450                                                                                                                                                         TestType::SPARSE_READ,
 451                                                                                                                                                         format, spirvFormat) );
 452                         }
 453                 }
 454         }
 455
 456         testGroup->addChild(testGroupOpRead.release());
 457         testGroup->addChild(testGroupOpWrite.release());
 458         testGroup->addChild(testGroupOpSparseRead.release());
 459
 460         return testGroup.release();
 461 }
 462
 463 } // image
 464 } // vkt