layer: Add string to int

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<uint32_t>(std::strtoul(token.c_str(), nullptr, 16));
+    } else {
+        int_id = static_cast<uint32_t>(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<uint64_t>(std::strtoull(token.c_str(), nullptr, 16));
+    } else {
+        int_id = static_cast<uint64_t>(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<int32_t>(std::strtol(token.c_str(), nullptr, 16));
+    } else {
+        int_id = static_cast<int32_t>(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<uint64_t>(std::strtoll(token.c_str(), nullptr, 16));
+    } else {
+        int_id = static_cast<uint64_t>(std::strtoll(token.c_str(), nullptr, 10));  // Decimal format
+    }
+    return int_id;
+}
+
 VkFrameset ToFrameSet(const std::string &s) {
     assert(IsFrameSets(s));
 

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);

src/layer/vk_layer_settings.cpp

@@ -462,45 +462,94 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
             return result;
         }
         case VK_LAYER_SETTING_TYPE_STRING_EXT: {
-                std::vector<const char*> values;
+            VkResult result = VK_SUCCESS;
-                VkResult result = VK_SUCCESS;
 
-                if (!settings.empty()) {  // From env variable or setting file
+            std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
-                    std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
-                    settings_cache = settings;
 
-                    if (copy_values) {
+            if (!settings.empty()) {  // From env variable or setting file
-                        if (static_cast<std::size_t>(*pValueCount) < settings_cache.size()) {
+                settings_cache = settings;
-                            result = VK_INCOMPLETE;
-                        }
-                        values.resize(std::min(static_cast<std::size_t>(*pValueCount), settings_cache.size()));
-
-                        for (std::size_t i = 0, n = values.size(); i < n; ++i) {
-                            values[i] = settings_cache[i].c_str();
-                        }
-                    } else {
-                        *pValueCount = static_cast<std::uint32_t>(settings_cache.size());
-                    }
-                } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                    if (api_setting->type != type) {
-                        result = VK_ERROR_FORMAT_NOT_SUPPORTED;
-                    } else 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) {
-                    std::copy(values.begin(), values.end(), reinterpret_cast<const char **>(pValues));
+                    if (static_cast<std::size_t>(*pValueCount) < settings_cache.size()) {
+                        result = VK_INCOMPLETE;
+                    }
+                } else {
+                    *pValueCount = static_cast<std::uint32_t>(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);
+                    settings_cache.resize(size);
 
-                return result;
+                    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;
+                }
             }
+
+            if (copy_values) {
+                for (std::size_t i = 0, n = std::min(static_cast<std::size_t>(*pValueCount), settings_cache.size()); i < n; ++i) {
+                    reinterpret_cast<const char **>(pValues)[i] = settings_cache[i].c_str();
+                }
+            }
+
+            return result;
+        }
     }
 
     return VK_ERROR_UNKNOWN;

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)

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 <christophe@lunarg.com>
+#include <gtest/gtest.h>
+
+#include "vulkan/layer/vk_layer_settings.h"
+#include <vector>
+#include <cstring>
+
+TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
+    std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<VkBool32> 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<const char*> 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<std::int32_t> input_values{76, -82};
+
+    std::vector<VkLayerSettingEXT> settings{
+        VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<std::int32_t> 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<const char*> 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<std::int64_t> input_values{76, -82};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<std::int64_t> 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<const char*> 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<std::uint32_t> input_values{76, 82};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<std::uint32_t> 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<const char*> 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<std::uint64_t> input_values{76, 82};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<std::uint64_t> 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<const char*> 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<float> input_values{76.1f, -82.5f};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<float> 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<const char*> 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<double> input_values{76.1, -82.5};
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<double> 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<const char*> 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<VkFrameset> input_values{
+        {76, 100, 10}, {1, 100, 1}
+    };
+
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<VkFrameset> 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<const char*> 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<const char*> input_values{"VALUE_A", "VALUE_B"};
+    std::vector<VkLayerSettingEXT> settings{
+        {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
+    };
+
+    VkLayerSettingsCreateInfoEXT layer_settings_create_info{
+        VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(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<const char*> 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);
+}

tests/layer/test_setting_util.cpp

@@ -319,6 +319,53 @@ 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(65535, vl::ToInt32("0xFFFF"));
+    EXPECT_EQ(-65535, vl::ToInt32("-0xFFFF"));
+    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"));