external/vulkancts/modules/vulkan/api/vktApiToolingInfoTests.cpp

   1 /*-------------------------------------------------------------------------
   2 * Vulkan Conformance Tests
   3 * ------------------------
   4 *
   5 * Copyright (c) 2019 Advanced Micro Devices, Inc.
   6 * Copyright (c) 2019 The Khronos Group Inc.
   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 VK_EXT_tooling_info tests
  23 *//*--------------------------------------------------------------------*/
  24
  25 #include "vktApiToolingInfoTests.hpp"
  26 #include "vktTestGroupUtil.hpp"
  27 #include "vktTestCaseUtil.hpp"
  28 #include "vkQueryUtil.hpp"
  29 #include "vkStrUtil.hpp"
  30 #include "vkTypeUtil.hpp"
  31 #include "tcuTestLog.hpp"
  32 #include <iostream>
  33 #include <string>
  34 #include <vector>
  35
  36 #include <string.h>
  37
  38 using namespace vk;
  39
  40 namespace vkt
  41 {
  42 namespace api
  43 {
  44 namespace
  45 {
  46
  47 bool validateToolPurposeFlagBits(const VkToolPurposeFlagsEXT purposes)
  48 {
  49         const VkToolPurposeFlagsEXT validPurposes =     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT                      |
  50                                                                                                 VK_TOOL_PURPOSE_PROFILING_BIT_EXT                       |
  51                                                                                                 VK_TOOL_PURPOSE_TRACING_BIT_EXT                         |
  52                                                                                                 VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT     |
  53                                                                                                 VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT      |
  54                                                                                                 VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT         |
  55                                                                                                 VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT;
  56         return (purposes | validPurposes) == validPurposes;
  57 }
  58
  59 void checkSupport (Context& context)
  60 {
  61         context.requireDeviceFunctionality("VK_EXT_tooling_info");
  62 }
  63
  64 tcu::TestStatus validateGetter(Context& context)
  65 {
  66         tcu::TestLog& testLog = context.getTestContext().getLog();
  67
  68         VkResult result         = VK_SUCCESS;
  69         deUint32 toolCount      = 0;
  70
  71         result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, DE_NULL);
  72
  73         if(result != VK_SUCCESS)
  74         {
  75                 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
  76                 return tcu::TestStatus::fail("Fail");
  77         }
  78
  79         if (toolCount > 0)
  80         {
  81                 deUint32 toolCountSecondCall = toolCount;
  82
  83                 std::vector<VkPhysicalDeviceToolPropertiesEXT>  deviceToolPropertiesEXTArray(toolCountSecondCall);
  84
  85                 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
  86
  87                 if (result != VK_SUCCESS)
  88                 {
  89                         testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
  90                         return tcu::TestStatus::fail("Fail");
  91                 }
  92
  93                 if (toolCountSecondCall != toolCount)
  94                 {
  95                         testLog << tcu::TestLog::Message << "Got different tools count on the second call" << tcu::TestLog::EndMessage;
  96                         return tcu::TestStatus::fail("Fail");
  97                 }
  98
  99                 toolCountSecondCall++;
 100
 101                 deviceToolPropertiesEXTArray.resize(toolCountSecondCall);
 102
 103                 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
 104
 105                 if (result != VK_SUCCESS)
 106                 {
 107                         testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
 108                         return tcu::TestStatus::fail("Fail");
 109                 }
 110
 111                 if (toolCountSecondCall != toolCount)
 112                 {
 113                         testLog << tcu::TestLog::Message << "Bigger array causes an error" << tcu::TestLog::EndMessage;
 114                         return tcu::TestStatus::fail("Fail");
 115                 }
 116
 117                 toolCountSecondCall = 0;
 118
 119                 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
 120
 121                 if (result != VK_INCOMPLETE)
 122                 {
 123                         testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
 124                         return tcu::TestStatus::fail("Fail");
 125                 }
 126
 127                 if (toolCountSecondCall != 0)
 128                 {
 129                         testLog << tcu::TestLog::Message << "Zero array causes an error" << tcu::TestLog::EndMessage;
 130                         return tcu::TestStatus::fail("Fail");
 131                 }
 132         }
 133
 134         if (toolCount > 1)
 135         {
 136                 deUint32 toolCountSecondCall = toolCount / 2;
 137
 138                 std::vector<VkPhysicalDeviceToolPropertiesEXT>  deviceToolPropertiesEXTArray(toolCountSecondCall);
 139
 140                 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
 141
 142                 if (result != VK_INCOMPLETE)
 143                 {
 144                         testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
 145                         return tcu::TestStatus::fail("Fail");
 146                 }
 147
 148                 if (toolCountSecondCall != (toolCount / 2))
 149                 {
 150                         testLog << tcu::TestLog::Message << "Smaller array causes an error" << tcu::TestLog::EndMessage;
 151                         return tcu::TestStatus::fail("Fail");
 152                 }
 153         }
 154
 155         return tcu::TestStatus::pass("Pass");
 156 }
 157
 158 tcu::TestStatus validateToolsProperties (Context& context)
 159 {
 160         tcu::TestLog& testLog = context.getTestContext().getLog();
 161
 162         bool     result         = true;
 163         deUint32 toolCount      = 0;
 164
 165         VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, DE_NULL));
 166
 167         if (toolCount > 0)
 168         {
 169                 std::vector<VkPhysicalDeviceToolPropertiesEXT>  deviceToolPropertiesEXTArray(toolCount);
 170
 171                 VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, &deviceToolPropertiesEXTArray[0]));
 172
 173                 for (deUint32 i = 0; i < toolCount; ++i)
 174                 {
 175                         size_t nameSize         = strnlen(deviceToolPropertiesEXTArray[i].name, VK_MAX_EXTENSION_NAME_SIZE);
 176                         size_t versionSize      = strnlen(deviceToolPropertiesEXTArray[i].version, VK_MAX_EXTENSION_NAME_SIZE);
 177                         size_t descSize         = strnlen(deviceToolPropertiesEXTArray[i].description, VK_MAX_DESCRIPTION_SIZE);
 178                         size_t layerSize        = strnlen(deviceToolPropertiesEXTArray[i].layer, VK_MAX_EXTENSION_NAME_SIZE);
 179
 180                         result = result && (deviceToolPropertiesEXTArray[i].sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT);
 181                         result = result && validateToolPurposeFlagBits(deviceToolPropertiesEXTArray[i].purposes);
 182                         result = result && ((nameSize > 0)              && (nameSize < VK_MAX_EXTENSION_NAME_SIZE));
 183                         result = result && ((versionSize > 0)   && (versionSize < VK_MAX_EXTENSION_NAME_SIZE));
 184                         result = result && ((descSize > 0)              && (descSize < VK_MAX_DESCRIPTION_SIZE));
 185                         result = result && ((layerSize == 0)    || (layerSize < VK_MAX_EXTENSION_NAME_SIZE));
 186
 187                         if (result == false)
 188                         {
 189                                 testLog << tcu::TestLog::Message << "Tool validation failed" << tcu::TestLog::EndMessage;
 190                                 testLog << tcu::TestLog::Message << "Tool name: " << deviceToolPropertiesEXTArray[i].name << tcu::TestLog::EndMessage;
 191                                 testLog << tcu::TestLog::Message << "Version: " << deviceToolPropertiesEXTArray[i].version << tcu::TestLog::EndMessage;
 192                                 testLog << tcu::TestLog::Message << "Description: " << deviceToolPropertiesEXTArray[i].description << tcu::TestLog::EndMessage;
 193                                 testLog << tcu::TestLog::Message << "Purposes: " << getToolPurposeFlagsEXTStr(deviceToolPropertiesEXTArray[i].purposes) << tcu::TestLog::EndMessage;
 194                                 if (layerSize > 0)
 195                                 {
 196                                         testLog << tcu::TestLog::Message << "Corresponding Layer: " << deviceToolPropertiesEXTArray[i].layer << tcu::TestLog::EndMessage;
 197                                 }
 198
 199                                 break;
 200                         }
 201                 }
 202         }
 203
 204         if (result)
 205         {
 206                 return tcu::TestStatus::pass("Pass");
 207         }
 208         else
 209         {
 210                 return tcu::TestStatus::fail("Fail");
 211         }
 212 }
 213
 214 void createTestCases (tcu::TestCaseGroup* group)
 215 {
 216         addFunctionCase(group, "validate_getter", "Validate getPhysicalDeviceToolPropertiesEXT", checkSupport, validateGetter);
 217         addFunctionCase(group, "validate_tools_properties","Validate tools properties", checkSupport, validateToolsProperties);
 218 }
 219
 220 } // anonymous
 221
 222 tcu::TestCaseGroup*     createToolingInfoTests(tcu::TestContext& testCtx)
 223 {
 224         return createTestGroup(testCtx, "tooling_info", "VK_EXT_tooling_info tests", createTestCases);
 225 }
 226
 227 } // api
 228 } // vkt