Rename various things for more inclusive language

[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / api / vktApiVersionCheck.cpp

diff --git a/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp b/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
index 0cc13d6..0af3341 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
@@ -127,8 +127,8 @@ public:
                                                                APIEntryPointsTestInstance      (Context&                               ctx)
                                                                        : TestInstance  (ctx)
        {
-
        }
+
        virtual tcu::TestStatus         iterate                                         (void)
        {
                tcu::TestLog&                                           log                             = m_context.getTestContext().getLog();
@@ -183,23 +183,23 @@ public:
                                extFunctions.push_back(FunctionInfo("vkGetImageMemoryRequirements2KHR", FUNCTIONORIGIN_DEVICE));
 
                                log << tcu::TestLog::Message << "Disabled extensions check - tries to get functions of disabled extensions from proper vkGet*ProcAddr." << tcu::TestLog::EndMessage;
-                               const char * const                              result                          = specialCasesCheck(ctx, log, failsQuantity, extFunctions) ? "Passed" : "Failed";
+                               const char * const                              result                                  = specialCasesCheck(ctx, log, failsQuantity, extFunctions) ? "Passed" : "Failed";
                                log << tcu::TestLog::Message << result << tcu::TestLog::EndMessage;
                        }
 
                        // Check special cases
                        {
-                               FunctionInfosList                               dummyFunctions          = FunctionInfosList();
+                               FunctionInfosList                               nonexistingFunctions    = FunctionInfosList();
                                for (deUint32 i = 0; i <= FUNCTIONORIGIN_DEVICE; ++i)
                                {
                                        const FunctionOrigin origin = static_cast<FunctionOrigin>(i);
-                                       dummyFunctions.push_back(FunctionInfo("vkSomeName", origin));
-                                       dummyFunctions.push_back(FunctionInfo("vkNonexistingKHR", origin));
-                                       dummyFunctions.push_back(FunctionInfo("", origin));
+                                       nonexistingFunctions.push_back(FunctionInfo("vkSomeName", origin));
+                                       nonexistingFunctions.push_back(FunctionInfo("vkNonexistingKHR", origin));
+                                       nonexistingFunctions.push_back(FunctionInfo("", origin));
                                }
 
-                               log << tcu::TestLog::Message << "Special check - tries to get some dummy functions from various vkGet*ProcAddr." << tcu::TestLog::EndMessage;
-                               const char * const                              result                          = specialCasesCheck(ctx, log, failsQuantity, dummyFunctions) ? "Passed" : "Failed";
+                               log << tcu::TestLog::Message << "Special check - tries to get some nonexisting functions from various vkGet*ProcAddr." << tcu::TestLog::EndMessage;
+                               const char * const                              result                          = specialCasesCheck(ctx, log, failsQuantity, nonexistingFunctions) ? "Passed" : "Failed";
                                log << tcu::TestLog::Message << result << tcu::TestLog::EndMessage;
                        }
                }
@@ -220,12 +220,19 @@ public:
                                for (size_t instanceExtNdx = 0; instanceExtNdx < DE_LENGTH_OF_ARRAY(instanceExtensionNames); instanceExtNdx++)
                                {
                                        vector<const char*> instanceExtFunctions;
+                                       vector<const char*> deviceExtFunctions;
 
                                        if (isSupportedInstanceExt(instanceExtensionNames[instanceExtNdx], apiVersion))
+                                       {
                                                getInstanceExtensionFunctions(apiVersion, instanceExtensionNames[instanceExtNdx], instanceExtFunctions);
+                                               getDeviceExtensionFunctions(apiVersion, instanceExtensionNames[instanceExtNdx], deviceExtFunctions);
+                                       }
 
                                        for (size_t instanceFuncNdx = 0; instanceFuncNdx < instanceExtFunctions.size(); instanceFuncNdx++)
                                                extFunctions.push_back(FunctionInfo(instanceExtFunctions[instanceFuncNdx], FUNCTIONORIGIN_INSTANCE));
+
+                                       for (size_t deviceFuncNdx = 0; deviceFuncNdx < deviceExtFunctions.size(); deviceFuncNdx++)
+                                               extFunctions.push_back(FunctionInfo(deviceExtFunctions[deviceFuncNdx], FUNCTIONORIGIN_DEVICE));
                                }
 
                                // Add supported device extension functions
@@ -443,16 +450,22 @@ private:
                const deUint32 startingQuantity = failsQuantity;
                for (deUint32 ndx = 0u; ndx < testsArr.size(); ++ndx)
                {
-                       if (deStringEqual(testsArr[ndx].first, "vkGetInstanceProcAddr") || deStringEqual(testsArr[ndx].first, "vkEnumerateInstanceVersion"))
+                       if (deStringEqual(testsArr[ndx].first, "vkGetInstanceProcAddr") && m_context.getUsedApiVersion() < VK_API_VERSION_1_2)
                                continue;
 
                        const deUint32 functionType     = testsArr[ndx].second;
                        if (functionType == FUNCTIONORIGIN_PLATFORM)
                                checkPlatformFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
                        else if (functionType == FUNCTIONORIGIN_INSTANCE)
+                       {
                                checkInstanceFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
+                               checkDeviceFunction(ctx, log, testsArr[ndx].first, DE_FALSE, failsQuantity);
+                       }
                        else if (functionType == FUNCTIONORIGIN_DEVICE)
+                       {
+                               checkInstanceFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
                                checkDeviceFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
+                       }
                }
                return startingQuantity == failsQuantity;
        }