external/vulkancts/modules/vulkan/vktTestPackage.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   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 Vulkan Test Package
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktTestPackage.hpp"
  25
  26 #include "tcuPlatform.hpp"
  27 #include "tcuTestCase.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "tcuCommandLine.hpp"
  30 #include "tcuWaiverUtil.hpp"
  31
  32 #include "vkPlatform.hpp"
  33 #include "vkPrograms.hpp"
  34 #include "vkBinaryRegistry.hpp"
  35 #include "vkShaderToSpirV.hpp"
  36 #include "vkDebugReportUtil.hpp"
  37 #include "vkQueryUtil.hpp"
  38 #include "vkApiVersion.hpp"
  39 #include "vkRenderDocUtil.hpp"
  40
  41 #include "deUniquePtr.hpp"
  42
  43 #include "vktTestGroupUtil.hpp"
  44 #include "vktApiTests.hpp"
  45 #include "vktPipelineTests.hpp"
  46 #include "vktBindingModelTests.hpp"
  47 #include "vktSpvAsmTests.hpp"
  48 #include "vktShaderLibrary.hpp"
  49 #include "vktRenderPassTests.hpp"
  50 #include "vktMemoryTests.hpp"
  51 #include "vktShaderRenderBuiltinVarTests.hpp"
  52 #include "vktShaderRenderDerivateTests.hpp"
  53 #include "vktShaderRenderDiscardTests.hpp"
  54 #include "vktShaderRenderIndexingTests.hpp"
  55 #include "vktShaderRenderInvarianceTests.hpp"
  56 #include "vktShaderRenderLimitTests.hpp"
  57 #include "vktShaderRenderLoopTests.hpp"
  58 #include "vktShaderRenderMatrixTests.hpp"
  59 #include "vktShaderRenderOperatorTests.hpp"
  60 #include "vktShaderRenderReturnTests.hpp"
  61 #include "vktShaderRenderStructTests.hpp"
  62 #include "vktShaderRenderSwitchTests.hpp"
  63 #include "vktShaderRenderTextureFunctionTests.hpp"
  64 #include "vktShaderRenderTextureGatherTests.hpp"
  65 #include "vktShaderBuiltinTests.hpp"
  66 #include "vktOpaqueTypeIndexingTests.hpp"
  67 #include "vktAtomicOperationTests.hpp"
  68 #include "vktUniformBlockTests.hpp"
  69 #include "vktDynamicStateTests.hpp"
  70 #include "vktSSBOLayoutTests.hpp"
  71 #include "vktQueryPoolTests.hpp"
  72 #include "vktDrawTests.hpp"
  73 #include "vktComputeTests.hpp"
  74 #include "vktConditionalTests.hpp"
  75 #include "vktImageTests.hpp"
  76 #include "vktInfoTests.hpp"
  77 #include "vktWsiTests.hpp"
  78 #include "vktSynchronizationTests.hpp"
  79 #include "vktSparseResourcesTests.hpp"
  80 #include "vktTessellationTests.hpp"
  81 #include "vktRasterizationTests.hpp"
  82 #include "vktClippingTests.hpp"
  83 #include "vktFragmentOperationsTests.hpp"
  84 #include "vktTextureTests.hpp"
  85 #include "vktGeometryTests.hpp"
  86 #include "vktRobustnessTests.hpp"
  87 #include "vktMultiViewTests.hpp"
  88 #include "vktSubgroupsTests.hpp"
  89 #include "vktYCbCrTests.hpp"
  90 #include "vktProtectedMemTests.hpp"
  91 #include "vktDeviceGroupTests.hpp"
  92 #include "vktMemoryModelTests.hpp"
  93 #include "vktAmberGraphicsFuzzTests.hpp"
  94 #include "vktAmberGlslTests.hpp"
  95 #include "vktImagelessFramebufferTests.hpp"
  96 #include "vktTransformFeedbackTests.hpp"
  97 #include "vktDescriptorIndexingTests.hpp"
  98 #include "vktImagelessFramebufferTests.hpp"
  99 #include "vktFragmentShaderInterlockTests.hpp"
 100 #include "vktShaderClockTests.hpp"
 101 #include "vktModifiersTests.hpp"
 102 #include "vktRayTracingTests.hpp"
 103 #include "vktRayQueryTests.hpp"
 104 #include "vktPostmortemTests.hpp"
 105 #include "vktFragmentShadingRateTests.hpp"
 106 #include "vktReconvergenceTests.hpp"
 107 #include "vktDynamicRenderingTests.hpp"
 108
 109 #include <vector>
 110 #include <sstream>
 111
 112 namespace // compilation
 113 {
 114
 115 vk::ProgramBinary* compileProgram (const vk::GlslSource& source, glu::ShaderProgramInfo* buildInfo, const tcu::CommandLine& commandLine)
 116 {
 117         return vk::buildProgram(source, buildInfo, commandLine);
 118 }
 119
 120 vk::ProgramBinary* compileProgram (const vk::HlslSource& source, glu::ShaderProgramInfo* buildInfo, const tcu::CommandLine& commandLine)
 121 {
 122         return vk::buildProgram(source, buildInfo, commandLine);
 123 }
 124
 125 vk::ProgramBinary* compileProgram (const vk::SpirVAsmSource& source, vk::SpirVProgramInfo* buildInfo, const tcu::CommandLine& commandLine)
 126 {
 127         return vk::assembleProgram(source, buildInfo, commandLine);
 128 }
 129
 130 template <typename InfoType, typename IteratorType>
 131 vk::ProgramBinary* buildProgram (const std::string&                                     casePath,
 132                                                                  IteratorType                                           iter,
 133                                                                  const vk::BinaryRegistryReader&        prebuiltBinRegistry,
 134                                                                  tcu::TestLog&                                          log,
 135                                                                  vk::BinaryCollection*                          progCollection,
 136                                                                  const tcu::CommandLine&                        commandLine)
 137 {
 138         const vk::ProgramIdentifier             progId          (casePath, iter.getName());
 139         const tcu::ScopedLogSection             progSection     (log, iter.getName(), "Program: " + iter.getName());
 140         de::MovePtr<vk::ProgramBinary>  binProg;
 141         InfoType                                                buildInfo;
 142
 143         try
 144         {
 145                 binProg = de::MovePtr<vk::ProgramBinary>(compileProgram(iter.getProgram(), &buildInfo, commandLine));
 146                 log << buildInfo;
 147         }
 148         catch (const tcu::NotSupportedError& err)
 149         {
 150                 // Try to load from cache
 151                 log << err << tcu::TestLog::Message << "Building from source not supported, loading stored binary instead" << tcu::TestLog::EndMessage;
 152
 153                 binProg = de::MovePtr<vk::ProgramBinary>(prebuiltBinRegistry.loadProgram(progId));
 154
 155                 log << iter.getProgram();
 156         }
 157         catch (const tcu::Exception&)
 158         {
 159                 // Build failed for other reason
 160                 log << buildInfo;
 161                 throw;
 162         }
 163
 164         TCU_CHECK_INTERNAL(binProg);
 165
 166         {
 167                 vk::ProgramBinary* const        returnBinary    = binProg.get();
 168
 169                 progCollection->add(progId.programName, binProg);
 170
 171                 return returnBinary;
 172         }
 173 }
 174
 175 } // anonymous(compilation)
 176
 177 namespace vkt
 178 {
 179
 180 using std::vector;
 181 using de::UniquePtr;
 182 using de::MovePtr;
 183 using tcu::TestLog;
 184
 185 // TestCaseExecutor
 186
 187 class TestCaseExecutor : public tcu::TestCaseExecutor
 188 {
 189 public:
 190                                                                                                 TestCaseExecutor        (tcu::TestContext& testCtx);
 191                                                                                                 ~TestCaseExecutor       (void);
 192
 193         virtual void                                                            init                            (tcu::TestCase* testCase, const std::string& path);
 194         virtual void                                                            deinit                          (tcu::TestCase* testCase);
 195
 196         virtual tcu::TestNode::IterateResult            iterate                         (tcu::TestCase* testCase);
 197
 198 private:
 199         void                                                                            logUnusedShaders        (tcu::TestCase* testCase);
 200
 201         bool                                                                            spirvVersionSupported(vk::SpirvVersion);
 202         vk::BinaryCollection                                            m_progCollection;
 203         vk::BinaryRegistryReader                                        m_prebuiltBinRegistry;
 204
 205         const UniquePtr<vk::Library>                            m_library;
 206         Context                                                                         m_context;
 207
 208         const UniquePtr<vk::RenderDocUtil>                      m_renderDoc;
 209         vk::VkPhysicalDeviceProperties                          m_deviceProperties;
 210         tcu::WaiverUtil                                                         m_waiverMechanism;
 211
 212         TestInstance*                                                           m_instance;                     //!< Current test case instance
 213 };
 214
 215 static MovePtr<vk::Library> createLibrary (tcu::TestContext& testCtx)
 216 {
 217         return MovePtr<vk::Library>(testCtx.getPlatform().getVulkanPlatform().createLibrary());
 218 }
 219
 220 static vk::VkPhysicalDeviceProperties getPhysicalDeviceProperties(vkt::Context& context)
 221 {
 222         const vk::InstanceInterface&    vki                             = context.getInstanceInterface();
 223         const vk::VkPhysicalDevice              physicalDevice  = context.getPhysicalDevice();
 224
 225         vk::VkPhysicalDeviceProperties  properties;
 226         vki.getPhysicalDeviceProperties(physicalDevice, &properties);
 227         return properties;
 228 }
 229
 230 TestCaseExecutor::TestCaseExecutor (tcu::TestContext& testCtx)
 231         : m_prebuiltBinRegistry (testCtx.getArchive(), "vulkan/prebuilt")
 232         , m_library                             (createLibrary(testCtx))
 233         , m_context                             (testCtx, m_library->getPlatformInterface(), m_progCollection)
 234         , m_renderDoc                   (testCtx.getCommandLine().isRenderDocEnabled()
 235                                                          ? MovePtr<vk::RenderDocUtil>(new vk::RenderDocUtil())
 236                                                          : MovePtr<vk::RenderDocUtil>(DE_NULL))
 237         , m_deviceProperties    (getPhysicalDeviceProperties(m_context))
 238         , m_instance                    (DE_NULL)
 239 {
 240         tcu::SessionInfo sessionInfo(m_deviceProperties.vendorID,
 241                                                                  m_deviceProperties.deviceID,
 242                                                                  testCtx.getCommandLine().getInitialCmdLine());
 243         m_waiverMechanism.setup(testCtx.getCommandLine().getWaiverFileName(),
 244                                                         "dEQP-VK",
 245                                                         m_deviceProperties.vendorID,
 246                                                         m_deviceProperties.deviceID,
 247                                                         sessionInfo);
 248         testCtx.getLog().writeSessionInfo(sessionInfo.get());
 249 }
 250
 251 TestCaseExecutor::~TestCaseExecutor (void)
 252 {
 253         delete m_instance;
 254 }
 255
 256 void TestCaseExecutor::init (tcu::TestCase* testCase, const std::string& casePath)
 257 {
 258         TestCase*                                       vktCase                                         = dynamic_cast<TestCase*>(testCase);
 259         tcu::TestLog&                           log                                                     = m_context.getTestContext().getLog();
 260         const deUint32                          usedVulkanVersion                       = m_context.getUsedApiVersion();
 261         const vk::SpirvVersion          baselineSpirvVersion            = vk::getBaselineSpirvVersion(usedVulkanVersion);
 262         vk::ShaderBuildOptions          defaultGlslBuildOptions         (usedVulkanVersion, baselineSpirvVersion, 0u);
 263         vk::ShaderBuildOptions          defaultHlslBuildOptions         (usedVulkanVersion, baselineSpirvVersion, 0u);
 264         vk::SpirVAsmBuildOptions        defaultSpirvAsmBuildOptions     (usedVulkanVersion, baselineSpirvVersion);
 265         vk::SourceCollections           sourceProgs                                     (usedVulkanVersion, defaultGlslBuildOptions, defaultHlslBuildOptions, defaultSpirvAsmBuildOptions);
 266         const tcu::CommandLine&         commandLine                                     = m_context.getTestContext().getCommandLine();
 267         const bool                                      doShaderLog                                     = commandLine.isLogDecompiledSpirvEnabled() && log.isShaderLoggingEnabled();
 268
 269         if (!vktCase)
 270                 TCU_THROW(InternalError, "Test node not an instance of vkt::TestCase");
 271
 272         if (m_waiverMechanism.isOnWaiverList(casePath))
 273                 throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
 274
 275         vktCase->checkSupport(m_context);
 276
 277         vktCase->delayedInit();
 278
 279         m_progCollection.clear();
 280         vktCase->initPrograms(sourceProgs);
 281
 282         for (vk::GlslSourceCollection::Iterator progIter = sourceProgs.glslSources.begin(); progIter != sourceProgs.glslSources.end(); ++progIter)
 283         {
 284                 if (!spirvVersionSupported(progIter.getProgram().buildOptions.targetVersion))
 285                         TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
 286
 287                 const vk::ProgramBinary* const binProg = buildProgram<glu::ShaderProgramInfo, vk::GlslSourceCollection::Iterator>(casePath, progIter, m_prebuiltBinRegistry, log, &m_progCollection, commandLine);
 288
 289                 if (doShaderLog)
 290                 {
 291                         try
 292                         {
 293                                 std::ostringstream disasm;
 294
 295                                 vk::disassembleProgram(*binProg, &disasm);
 296
 297                                 log << vk::SpirVAsmSource(disasm.str());
 298                         }
 299                         catch (const tcu::NotSupportedError& err)
 300                         {
 301                                 log << err;
 302                         }
 303                 }
 304         }
 305
 306         for (vk::HlslSourceCollection::Iterator progIter = sourceProgs.hlslSources.begin(); progIter != sourceProgs.hlslSources.end(); ++progIter)
 307         {
 308                 if (!spirvVersionSupported(progIter.getProgram().buildOptions.targetVersion))
 309                         TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
 310
 311                 const vk::ProgramBinary* const binProg = buildProgram<glu::ShaderProgramInfo, vk::HlslSourceCollection::Iterator>(casePath, progIter, m_prebuiltBinRegistry, log, &m_progCollection, commandLine);
 312
 313                 if (doShaderLog)
 314                 {
 315                         try
 316                         {
 317                                 std::ostringstream disasm;
 318
 319                                 vk::disassembleProgram(*binProg, &disasm);
 320
 321                                 log << vk::SpirVAsmSource(disasm.str());
 322                         }
 323                         catch (const tcu::NotSupportedError& err)
 324                         {
 325                                 log << err;
 326                         }
 327                 }
 328         }
 329
 330         for (vk::SpirVAsmCollection::Iterator asmIterator = sourceProgs.spirvAsmSources.begin(); asmIterator != sourceProgs.spirvAsmSources.end(); ++asmIterator)
 331         {
 332                 if (!spirvVersionSupported(asmIterator.getProgram().buildOptions.targetVersion))
 333                         TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
 334
 335                 buildProgram<vk::SpirVProgramInfo, vk::SpirVAsmCollection::Iterator>(casePath, asmIterator, m_prebuiltBinRegistry, log, &m_progCollection, commandLine);
 336         }
 337
 338         if (m_renderDoc) m_renderDoc->startFrame(m_context.getInstance());
 339
 340         DE_ASSERT(!m_instance);
 341         m_instance = vktCase->createInstance(m_context);
 342         m_context.resultSetOnValidation(false);
 343 }
 344
 345 void TestCaseExecutor::deinit (tcu::TestCase* testCase)
 346 {
 347         delete m_instance;
 348         m_instance = DE_NULL;
 349
 350         if (m_renderDoc) m_renderDoc->endFrame(m_context.getInstance());
 351
 352         // Collect and report any debug messages
 353         if (m_context.hasDebugReportRecorder())
 354                 collectAndReportDebugMessages(m_context.getDebugReportRecorder(), m_context);
 355
 356         if (testCase != DE_NULL)
 357                 logUnusedShaders(testCase);
 358 }
 359
 360 void TestCaseExecutor::logUnusedShaders (tcu::TestCase* testCase)
 361 {
 362         const qpTestResult      testResult      = testCase->getTestContext().getTestResult();
 363
 364         if (testResult == QP_TEST_RESULT_PASS || testResult == QP_TEST_RESULT_QUALITY_WARNING || testResult == QP_TEST_RESULT_COMPATIBILITY_WARNING)
 365         {
 366                 bool    unusedShaders   = false;
 367
 368                 for (vk::BinaryCollection::Iterator it = m_progCollection.begin(); it != m_progCollection.end(); ++it)
 369                 {
 370                         if (!it.getProgram().getUsed())
 371                         {
 372                                 unusedShaders = true;
 373
 374                                 break;
 375                         }
 376                 }
 377
 378                 if (unusedShaders)
 379                 {
 380                         std::string message;
 381
 382                         for (vk::BinaryCollection::Iterator it = m_progCollection.begin(); it != m_progCollection.end(); ++it)
 383                         {
 384                                 if (!it.getProgram().getUsed())
 385                                         message += it.getName() + ",";
 386                         }
 387
 388                         message.resize(message.size() - 1);
 389
 390                         message = std::string("Unused shaders: ") + message;
 391
 392                         m_context.getTestContext().getLog() << TestLog::Message << message << TestLog::EndMessage;
 393                 }
 394         }
 395 }
 396
 397 tcu::TestNode::IterateResult TestCaseExecutor::iterate (tcu::TestCase*)
 398 {
 399         DE_ASSERT(m_instance);
 400
 401         const tcu::TestStatus   result  = m_instance->iterate();
 402
 403         if (result.isComplete())
 404         {
 405                 // Vulkan tests shouldn't set result directly except when using a debug report messenger to catch validation errors.
 406                 DE_ASSERT(m_context.getTestContext().getTestResult() == QP_TEST_RESULT_LAST || m_context.resultSetOnValidation());
 407
 408                 // Override result if not set previously by a debug report messenger.
 409                 if (!m_context.resultSetOnValidation())
 410                         m_context.getTestContext().setTestResult(result.getCode(), result.getDescription().c_str());
 411                 return tcu::TestNode::STOP;
 412         }
 413         else
 414                 return tcu::TestNode::CONTINUE;
 415 }
 416
 417 bool TestCaseExecutor::spirvVersionSupported (vk::SpirvVersion spirvVersion)
 418 {
 419         if (spirvVersion <= vk::getMaxSpirvVersionForVulkan(m_context.getUsedApiVersion()))
 420                 return true;
 421
 422         if (spirvVersion <= vk::SPIRV_VERSION_1_4)
 423                 return m_context.isDeviceFunctionalitySupported("VK_KHR_spirv_1_4");
 424
 425         return false;
 426 }
 427
 428 // GLSL shader tests
 429
 430 void createGlslTests (tcu::TestCaseGroup* glslTests)
 431 {
 432         tcu::TestContext&       testCtx         = glslTests->getTestContext();
 433
 434         // ShaderLibrary-based tests
 435         static const struct
 436         {
 437                 const char*             name;
 438                 const char*             description;
 439         } s_es310Tests[] =
 440         {
 441                 { "arrays",                                             "Arrays"                                        },
 442                 { "conditionals",                               "Conditional statements"        },
 443                 { "constant_expressions",               "Constant expressions"          },
 444                 { "constants",                                  "Constants"                                     },
 445                 { "conversions",                                "Type conversions"                      },
 446                 { "functions",                                  "Functions"                                     },
 447                 { "linkage",                                    "Linking"                                       },
 448                 { "scoping",                                    "Scoping"                                       },
 449                 { "swizzles",                                   "Swizzles"                                      },
 450         };
 451
 452         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_es310Tests); ndx++)
 453                 glslTests->addChild(createShaderLibraryGroup(testCtx,
 454                                                                                                          s_es310Tests[ndx].name,
 455                                                                                                          s_es310Tests[ndx].description,
 456                                                                                                          std::string("vulkan/glsl/es310/") + s_es310Tests[ndx].name + ".test").release());
 457
 458         static const struct
 459         {
 460                 const char*             name;
 461                 const char*             description;
 462         } s_440Tests[] =
 463         {
 464                 { "linkage",                                    "Linking"                                       },
 465         };
 466
 467         de::MovePtr<tcu::TestCaseGroup> glsl440Tests = de::MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(testCtx, "440", ""));
 468
 469         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_440Tests); ndx++)
 470                 glsl440Tests->addChild(createShaderLibraryGroup(testCtx,
 471                                                                                                          s_440Tests[ndx].name,
 472                                                                                                          s_440Tests[ndx].description,
 473                                                                                                          std::string("vulkan/glsl/440/") + s_440Tests[ndx].name + ".test").release());
 474
 475         glslTests->addChild(glsl440Tests.release());
 476
 477         // ShaderRenderCase-based tests
 478         glslTests->addChild(sr::createDerivateTests                     (testCtx));
 479         glslTests->addChild(sr::createDiscardTests                      (testCtx));
 480         glslTests->addChild(sr::createDemoteTests                       (testCtx));
 481         glslTests->addChild(sr::createIndexingTests                     (testCtx));
 482         glslTests->addChild(sr::createShaderInvarianceTests     (testCtx));
 483         glslTests->addChild(sr::createLimitTests                        (testCtx));
 484         glslTests->addChild(sr::createLoopTests                         (testCtx));
 485         glslTests->addChild(sr::createMatrixTests                       (testCtx));
 486         glslTests->addChild(sr::createOperatorTests                     (testCtx));
 487         glslTests->addChild(sr::createReturnTests                       (testCtx));
 488         glslTests->addChild(sr::createStructTests                       (testCtx));
 489         glslTests->addChild(sr::createSwitchTests                       (testCtx));
 490         glslTests->addChild(sr::createTextureFunctionTests      (testCtx));
 491         glslTests->addChild(sr::createTextureGatherTests        (testCtx));
 492         glslTests->addChild(sr::createBuiltinVarTests           (testCtx));
 493
 494         // ShaderExecutor-based tests
 495         glslTests->addChild(shaderexecutor::createBuiltinTests                          (testCtx));
 496         glslTests->addChild(shaderexecutor::createOpaqueTypeIndexingTests       (testCtx));
 497         glslTests->addChild(shaderexecutor::createAtomicOperationTests          (testCtx));
 498         glslTests->addChild(shaderexecutor::createShaderClockTests                      (testCtx));
 499
 500         // Amber GLSL tests.
 501         glslTests->addChild(cts_amber::createCombinedOperationsGroup            (testCtx));
 502 }
 503
 504 // TestPackage
 505
 506 BaseTestPackage::BaseTestPackage (tcu::TestContext& testCtx, const char* name, const char* desc)
 507         : tcu::TestPackage(testCtx, name, desc)
 508 {
 509 }
 510
 511 BaseTestPackage::~BaseTestPackage (void)
 512 {
 513 }
 514
 515 TestPackage::TestPackage (tcu::TestContext& testCtx)
 516         : BaseTestPackage(testCtx, "dEQP-VK", "dEQP Vulkan Tests")
 517 {
 518 }
 519
 520 TestPackage::~TestPackage (void)
 521 {
 522 }
 523
 524 ExperimentalTestPackage::ExperimentalTestPackage (tcu::TestContext& testCtx)
 525         : BaseTestPackage(testCtx, "dEQP-VK-experimental", "dEQP Vulkan Experimental Tests")
 526 {
 527 }
 528
 529 ExperimentalTestPackage::~ExperimentalTestPackage (void)
 530 {
 531 }
 532
 533 tcu::TestCaseExecutor* BaseTestPackage::createExecutor (void) const
 534 {
 535         return new TestCaseExecutor(m_testCtx);
 536 }
 537
 538 void TestPackage::init (void)
 539 {
 540         addChild(createTestGroup                                        (m_testCtx, "info", "Build and Device Info Tests", createInfoTests));
 541         addChild(api::createTests                                       (m_testCtx));
 542         addChild(memory::createTests                            (m_testCtx));
 543         addChild(pipeline::createTests                          (m_testCtx));
 544         addChild(BindingModel::createTests                      (m_testCtx));
 545         addChild(SpirVAssembly::createTests                     (m_testCtx));
 546         addChild(createTestGroup                                        (m_testCtx, "glsl", "GLSL shader execution tests", createGlslTests));
 547         addChild(createRenderPassTests                          (m_testCtx));
 548         addChild(createRenderPass2Tests                         (m_testCtx));
 549         addChild(createDynamicRenderingTests            (m_testCtx));
 550         addChild(ubo::createTests                                       (m_testCtx));
 551         addChild(DynamicState::createTests                      (m_testCtx));
 552         addChild(ssbo::createTests                                      (m_testCtx));
 553         addChild(QueryPool::createTests                         (m_testCtx));
 554         addChild(Draw::createTests                                      (m_testCtx));
 555         addChild(Draw::createDynamicRenderingTests      (m_testCtx));
 556         addChild(compute::createTests                           (m_testCtx));
 557         addChild(image::createTests                                     (m_testCtx));
 558         addChild(wsi::createTests                                       (m_testCtx));
 559         addChild(createSynchronizationTests                     (m_testCtx));
 560         addChild(createSynchronization2Tests            (m_testCtx));
 561         addChild(sparse::createTests                            (m_testCtx));
 562         addChild(tessellation::createTests                      (m_testCtx));
 563         addChild(rasterization::createTests                     (m_testCtx));
 564         addChild(clipping::createTests                          (m_testCtx));
 565         addChild(FragmentOperations::createTests        (m_testCtx));
 566         addChild(texture::createTests                           (m_testCtx));
 567         addChild(geometry::createTests                          (m_testCtx));
 568         addChild(robustness::createTests                        (m_testCtx));
 569         addChild(MultiView::createTests                         (m_testCtx));
 570         addChild(subgroups::createTests                         (m_testCtx));
 571         addChild(ycbcr::createTests                                     (m_testCtx));
 572         addChild(ProtectedMem::createTests                      (m_testCtx));
 573         addChild(DeviceGroup::createTests                       (m_testCtx));
 574         addChild(MemoryModel::createTests                       (m_testCtx));
 575         addChild(conditional::createTests                       (m_testCtx));
 576         addChild(cts_amber::createGraphicsFuzzTests     (m_testCtx));
 577         addChild(imageless::createTests                         (m_testCtx));
 578         addChild(TransformFeedback::createTests         (m_testCtx));
 579         addChild(DescriptorIndexing::createTests        (m_testCtx));
 580         addChild(FragmentShaderInterlock::createTests(m_testCtx));
 581         addChild(modifiers::createTests                         (m_testCtx));
 582         addChild(RayTracing::createTests                        (m_testCtx));
 583         addChild(RayQuery::createTests                          (m_testCtx));
 584         addChild(FragmentShadingRate::createTests       (m_testCtx, false));
 585         addChild(FragmentShadingRate::createTests       (m_testCtx, true));
 586         addChild(Reconvergence::createTests                     (m_testCtx, false));
 587         addChild(DynamicRendering::createTests          (m_testCtx));
 588 }
 589
 590 void ExperimentalTestPackage::init (void)
 591 {
 592         addChild(postmortem::createTests                        (m_testCtx));
 593         addChild(Reconvergence::createTests                     (m_testCtx, true));
 594 }
 595
 596 } // vkt