From 8fcb38ce1d540d76a944768270a0b4e739ca505a Mon Sep 17 00:00:00 2001 From: Christophe Date: Thu, 3 Aug 2023 17:10:25 +0200 Subject: [PATCH] layer: Add string to int --- src/layer/layer_settings_util.cpp | 40 ++++ src/layer/layer_settings_util.hpp | 8 + src/layer/vk_layer_settings.cpp | 107 +++++++--- tests/layer/CMakeLists.txt | 19 ++ tests/layer/test_setting_cast.cpp | 339 ++++++++++++++++++++++++++++++ tests/layer/test_setting_util.cpp | 49 +++++ 6 files changed, 534 insertions(+), 28 deletions(-) create mode 100644 tests/layer/test_setting_cast.cpp diff --git a/src/layer/layer_settings_util.cpp b/src/layer/layer_settings_util.cpp index a03d478..45fe9c8 100644 --- a/src/layer/layer_settings_util.cpp +++ b/src/layer/layer_settings_util.cpp @@ -158,6 +158,46 @@ std::string ToUpper(const std::string &s) { return result; } +uint32_t ToUint32(const std::string &token) { + uint32_t int_id = 0; + if ((token.find("0x") == 0) || token.find("0X") == 0) { // Handle hex format + int_id = static_cast(std::strtoul(token.c_str(), nullptr, 16)); + } else { + int_id = static_cast(std::strtoul(token.c_str(), nullptr, 10)); // Decimal format + } + return int_id; +} + +uint64_t ToUint64(const std::string &token) { + uint64_t int_id = 0; + if ((token.find("0x") == 0) || token.find("0X") == 0) { // Handle hex format + int_id = static_cast(std::strtoull(token.c_str(), nullptr, 16)); + } else { + int_id = static_cast(std::strtoull(token.c_str(), nullptr, 10)); // Decimal format + } + return int_id; +} + +int32_t ToInt32(const std::string &token) { + int32_t int_id = 0; + if (token.find("0x") == 0 || token.find("0X") == 0 || token.find("-0x") == 0 || token.find("-0X") == 0) { // Handle hex format + int_id = static_cast(std::strtol(token.c_str(), nullptr, 16)); + } else { + int_id = static_cast(std::strtol(token.c_str(), nullptr, 10)); // Decimal format + } + return int_id; +} + +int64_t ToInt64(const std::string &token) { + int64_t int_id = 0; + if (token.find("0x") == 0 || token.find("0X") == 0 || token.find("-0x") == 0 || token.find("-0X") == 0) { // Handle hex format + int_id = static_cast(std::strtoll(token.c_str(), nullptr, 16)); + } else { + int_id = static_cast(std::strtoll(token.c_str(), nullptr, 10)); // Decimal format + } + return int_id; +} + VkFrameset ToFrameSet(const std::string &s) { assert(IsFrameSets(s)); diff --git a/src/layer/layer_settings_util.hpp b/src/layer/layer_settings_util.hpp index 28a0f8f..ef58b47 100644 --- a/src/layer/layer_settings_util.hpp +++ b/src/layer/layer_settings_util.hpp @@ -52,6 +52,14 @@ namespace vl { std::string ToUpper(const std::string &s); + uint32_t ToUint32(const std::string &token); + + uint64_t ToUint64(const std::string &token); + + int32_t ToInt32(const std::string &token); + + int64_t ToInt64(const std::string &token); + bool IsFrameSets(const std::string &s); VkFrameset ToFrameSet(const std::string &s); diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp index 21fe30a..6ab475a 100644 --- a/src/layer/vk_layer_settings.cpp +++ b/src/layer/vk_layer_settings.cpp @@ -446,43 +446,94 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char * return result; } case VK_LAYER_SETTING_TYPE_STRING_EXT: { - std::vector values; - VkResult result = VK_SUCCESS; + VkResult result = VK_SUCCESS; - if (!settings.empty()) { // From env variable or setting file - std::vector &settings_cache = layer_setting_set->GetSettingCache(pSettingName); - settings_cache = settings; + std::vector &settings_cache = layer_setting_set->GetSettingCache(pSettingName); - if (copy_values) { - if (static_cast(*pValueCount) < settings_cache.size()) { - result = VK_INCOMPLETE; - } - values.resize(std::min(static_cast(*pValueCount), settings_cache.size())); + if (!settings.empty()) { // From env variable or setting file + settings_cache = settings; - for (std::size_t i = 0, n = values.size(); i < n; ++i) { - values[i] = settings_cache[i].c_str(); - } - } else { - *pValueCount = static_cast(settings_cache.size()); - } - } else if (api_setting != nullptr) { // From Vulkan Layer Setting API - if (copy_values) { - if (*pValueCount < api_setting->count) { - result = VK_INCOMPLETE; - } - const std::uint32_t size = std::min(*pValueCount, api_setting->count); - values.assign(api_setting->asString, api_setting->asString + size); - } else { - *pValueCount = api_setting->count; + if (copy_values) { + if (static_cast(*pValueCount) < settings_cache.size()) { + result = VK_INCOMPLETE; } + } else { + *pValueCount = static_cast(settings_cache.size()); } - + } else if (api_setting != nullptr) { // From Vulkan Layer Setting API if (copy_values) { - std::copy(values.begin(), values.end(), reinterpret_cast(pValues)); + if (*pValueCount < api_setting->count) { + result = VK_INCOMPLETE; + } + const std::uint32_t size = std::min(*pValueCount, api_setting->count); + settings_cache.resize(size); + + switch (api_setting->type) { + case VK_LAYER_SETTING_TYPE_STRING_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = api_setting->asString[i]; + } + break; + case VK_LAYER_SETTING_TYPE_BOOL_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = api_setting->asBool32[i] == VK_TRUE ? "true" : "false"; + } + break; + case VK_LAYER_SETTING_TYPE_INT32_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%d", api_setting->asInt32[i]); + } + break; + case VK_LAYER_SETTING_TYPE_INT64_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%d", api_setting->asInt64[i]); + } + break; + case VK_LAYER_SETTING_TYPE_UINT32_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%u", api_setting->asUint32[i]); + } + break; + case VK_LAYER_SETTING_TYPE_UINT64_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%u", api_setting->asUint64[i]); + } + break; + case VK_LAYER_SETTING_TYPE_FLOAT_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%f", api_setting->asFloat[i]); + } + break; + case VK_LAYER_SETTING_TYPE_DOUBLE_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%f", api_setting->asDouble[i]); + } + break; + case VK_LAYER_SETTING_TYPE_FRAMESET_EXT: + for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { + settings_cache[i] = vl::Format("%d-%d-%d", + api_setting->asFrameset[i].first, + api_setting->asFrameset[i].count, + api_setting->asFrameset[i].step); + } + break; + default: + result = VK_ERROR_FORMAT_NOT_SUPPORTED; + break; + } + } else { + *pValueCount = api_setting->count; } + } - return result; + if (copy_values) { + for (std::size_t i = 0, n = std::min(static_cast(*pValueCount), settings_cache.size()); i < n; ++i) { + reinterpret_cast(pValues)[i] = settings_cache[i].c_str(); + } } + + return result; + } } return VK_ERROR_UNKNOWN; diff --git a/tests/layer/CMakeLists.txt b/tests/layer/CMakeLists.txt index 9095d3b..0bb4c39 100644 --- a/tests/layer/CMakeLists.txt +++ b/tests/layer/CMakeLists.txt @@ -109,3 +109,22 @@ target_link_libraries(test_layer_setting_file PRIVATE gtest_discover_tests(test_layer_setting_file) +# test_layer_setting_cast +add_executable(test_layer_setting_cast) + +target_include_directories(test_layer_setting_cast PRIVATE + ${CMAKE_SOURCE_DIR}/src/layer +) + +target_sources(test_layer_setting_cast PRIVATE + test_setting_cast.cpp +) + +target_link_libraries(test_layer_setting_cast PRIVATE + GTest::gtest + GTest::gtest_main + Vulkan::Headers + Vulkan::LayerSettings +) + +gtest_discover_tests(test_layer_setting_cast) diff --git a/tests/layer/test_setting_cast.cpp b/tests/layer/test_setting_cast.cpp new file mode 100644 index 0000000..814bbe8 --- /dev/null +++ b/tests/layer/test_setting_cast.cpp @@ -0,0 +1,339 @@ +// Copyright 2023 The Khronos Group Inc. +// Copyright 2023 Valve Corporation +// Copyright 2023 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Author(s): +// - Christophe Riccio +#include + +#include "vulkan/layer/vk_layer_settings.h" +#include +#include + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) { + std::vector input_values{VK_TRUE, VK_FALSE}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast(input_values.size()), {&input_values[0]}}}; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_EQ(VK_TRUE, values[0]); + EXPECT_EQ(VK_FALSE, values[1]); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("true", string_values[0]); + EXPECT_STREQ("false", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) { + std::vector input_values{76, -82}; + + std::vector settings{ + VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast(input_values.size()), {&input_values[0]}}}; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(76, values[0]); + EXPECT_EQ(-82, values[1]); + EXPECT_EQ(2, value_count); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("76", string_values[0]); + EXPECT_STREQ("-82", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) { + std::vector input_values{76, -82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast(input_values.size()), {&input_values[0]}}}; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(76, values[0]); + EXPECT_EQ(-82, values[1]); + EXPECT_EQ(2, value_count); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("76", string_values[0]); + EXPECT_STREQ("-82", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + EXPECT_EQ(2, value_count); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("76", string_values[0]); + EXPECT_STREQ("82", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("76", string_values[0]); + EXPECT_STREQ("82", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) { + std::vector input_values{76.1f, -82.5f}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); + EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); + EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) { + std::vector input_values{76.1, -82.5}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); + EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); + EXPECT_EQ(2, value_count); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); + EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) { + std::vector input_values{ + {76, 100, 10}, {1, 100, 1} + }; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(76, values[0].first); + EXPECT_EQ(100, values[0].count); + EXPECT_EQ(10, values[0].step); + EXPECT_EQ(1, values[1].first); + EXPECT_EQ(100, values[1].count); + EXPECT_EQ(1, values[1].step); + EXPECT_EQ(2, value_count); + + std::vector string_values(input_values.size()); + + result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &string_values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_EQ(2, value_count); + EXPECT_STREQ("76-100-10", string_values[0]); + EXPECT_STREQ("1-100-1", string_values[1]); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) { + std::vector input_values{"VALUE_A", "VALUE_B"}; + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values(input_values.size()); + + uint32_t value_count = 2; + VkResult result_complete = + vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]); + EXPECT_EQ(VK_SUCCESS, result_complete); + EXPECT_STREQ("VALUE_A", values[0]); + EXPECT_STREQ("VALUE_B", values[1]); + EXPECT_EQ(2, value_count); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} diff --git a/tests/layer/test_setting_util.cpp b/tests/layer/test_setting_util.cpp index 4097a1d..0884386 100644 --- a/tests/layer/test_setting_util.cpp +++ b/tests/layer/test_setting_util.cpp @@ -319,6 +319,55 @@ TEST(test_layer_settings_util, is_float) { EXPECT_EQ(false, vl::IsFloat("A")); } +TEST(test_layer_settings_util, ToUint32) { + EXPECT_EQ(24, vl::ToUint32("24")); + EXPECT_EQ(3000300000, vl::ToUint32("3000300000")); + EXPECT_EQ(15, vl::ToUint32("0xF")); + EXPECT_EQ(15, vl::ToUint32("0XF")); + EXPECT_EQ(4294967295, vl::ToUint32("0xFFFFFFFF")); +} + +TEST(test_layer_settings_util, ToUint64) { + EXPECT_EQ(24, vl::ToUint64("24")); + EXPECT_EQ(3000300000, vl::ToUint64("3000300000")); + EXPECT_EQ(15, vl::ToUint64("0xF")); + EXPECT_EQ(15, vl::ToUint64("0XF")); + EXPECT_EQ(4294967295, vl::ToUint64("0xFFFFFFFF")); + EXPECT_EQ(4294967296ull, vl::ToUint64("0x100000000")); +} + +TEST(test_layer_settings_util, ToInt32) { + EXPECT_EQ(24, vl::ToInt32("24")); + EXPECT_EQ(-24, vl::ToInt32("-24")); + EXPECT_EQ(2147483647, vl::ToInt32("2147483647")); + EXPECT_EQ(-2147483648, vl::ToInt32("-2147483648")); + EXPECT_EQ(2147483647, vl::ToInt32("2147483650")); + EXPECT_EQ(-2147483648, vl::ToInt32("-2147483650")); + EXPECT_EQ(2147483647, vl::ToInt32("0xFFFFFFFF")); + EXPECT_EQ(-2147483648, vl::ToInt32("-0xFFFFFFFF")); + EXPECT_EQ(15, vl::ToInt32("0xF")); + EXPECT_EQ(-15, vl::ToInt32("-0xF")); + EXPECT_EQ(15, vl::ToInt32("0XF")); + EXPECT_EQ(-15, vl::ToInt32("-0XF")); +} + +TEST(test_layer_settings_util, ToInt64) { + EXPECT_EQ(24LL, vl::ToInt64("24")); + EXPECT_EQ(-24LL, vl::ToInt64("-24")); + EXPECT_EQ(2147483647LL, vl::ToInt64("2147483647")); + EXPECT_EQ(-2147483648LL, vl::ToInt64("-2147483648")); + EXPECT_EQ(2147483650LL, vl::ToInt64("2147483650")); + EXPECT_EQ(-2147483650LL, vl::ToInt64("-2147483650")); + EXPECT_EQ(4294967295LL, vl::ToInt64("0xFFFFFFFF")); + EXPECT_EQ(-4294967295LL, vl::ToInt64("-0xFFFFFFFF")); + EXPECT_EQ(4294967296LL, vl::ToInt64("0x100000000")); + EXPECT_EQ(-4294967296LL, vl::ToInt64("-0x100000000")); + EXPECT_EQ(15LL, vl::ToInt64("0xF")); + EXPECT_EQ(-15LL, vl::ToInt64("-0xF")); + EXPECT_EQ(15LL, vl::ToInt64("0XF")); + EXPECT_EQ(-15LL, vl::ToInt64("-0XF")); +} + TEST(test_layer_settings_util, is_framesets) { EXPECT_EQ(true, vl::IsFrameSets("0")); EXPECT_EQ(true, vl::IsFrameSets("0-2"));