eden-emu/Vulkan-Utility-Libraries
15
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git synced 2025-06-01 17:37:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

layer: add layer settings set to handle multiple instances

Browse source
This commit is contained in:
Christophe 2023-06-05 18:56:23 +02:00 • committed by Christophe
parent 3f2d178323
commit c9f8cebf72
7 changed files with 306 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

15
include/vulkan/layer/vk_layer_settings.h
View file

@ -27,16 +27,23 @@ extern "C" {
#include "vk_layer_settings_ext.h"
VK_DEFINE_HANDLE(VlLayerSettingSet)
typedef void *(*VL_LAYER_SETTING_LOG_CALLBACK)(const char *pSettingName, const char *pMessage);
// Initialize the layer settings. If 'pCallback' is set to NULL, the messages are outputed to stderr.
void vlInitLayerSettings(const char *pLayerName, const VkInstanceCreateInfo *pCreateInfo, VL_LAYER_SETTING_LOG_CALLBACK pCallback);
// Create a layer setting set. If 'pCallback' is set to NULL, the messages are outputed to stderr.
VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VL_LAYER_SETTING_LOG_CALLBACK pCallback, VlLayerSettingSet *pLayerSettingSet);
void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator);
// Check whether a setting was set either programmatically, from vk_layer_settings.txt or an environment variable
VkBool32 vlHasLayerSetting(const char *pSettingName);
VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName);
// Query setting values
VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT type, uint32_t *pValueCount, void *pValues);
VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, VkLayerSettingTypeEXT type,
uint32_t *pValueCount, void *pValues);
#ifdef __cplusplus
}

6
src/layer/layer_settings_manager.cpp
View file

@ -103,8 +103,10 @@ static inline bool IsHighIntegrity() {
namespace vl {
LayerSettings::LayerSettings(const char *pLayerName, const VkInstanceCreateInfo *pCreateInfo, VL_LAYER_SETTING_LOG_CALLBACK callback)
: layer_name(pLayerName), create_info(FindSettingsInChain(pCreateInfo)), callback(callback) {
LayerSettings::LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VL_LAYER_SETTING_LOG_CALLBACK callback)
: layer_name(pLayerName), create_info(pCreateInfo), callback(callback) {
(void)pAllocator;
assert(pLayerName != nullptr);
std::string settings_file = this->FindSettingsFile();

5
src/layer/layer_settings_manager.hpp
View file

@ -47,7 +47,8 @@ namespace vl {
class LayerSettings {
public:
LayerSettings(const char *pLayerName, const VkInstanceCreateInfo *pCreateInfo, VL_LAYER_SETTING_LOG_CALLBACK callback);
LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VL_LAYER_SETTING_LOG_CALLBACK callback);
~LayerSettings();
bool HasEnvSetting(const char *pSettingName);
@ -81,7 +82,7 @@ namespace vl {
void ParseSettingsFile(const char *filename);
std::string layer_name;
const VkLayerSettingsCreateInfoEXT *create_info;
const VkLayerSettingsCreateInfoEXT *create_info{nullptr};
VL_LAYER_SETTING_LOG_CALLBACK callback{nullptr};
};
}// namespace vl

76
src/layer/vk_layer_settings.cpp
View file

@ -32,40 +32,58 @@
#include <cstring>
#include <cstdint>
static std::unique_ptr<vl::LayerSettings> vk_layer_settings;
void test_helper_SetLayerSetting(const char *pSettingName, const char* pValue) {
assert(vk_layer_settings);
// This is used only for unit tests in test_layer_setting_file
void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue) {
assert(layerSettingSet != VK_NULL_HANDLE);
assert(pSettingName != nullptr);
assert(pValue != nullptr);
vk_layer_settings->SetFileSetting(pSettingName, pValue);
vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
layer_setting_set->SetFileSetting(pSettingName, pValue);
}
void vlInitLayerSettings(const char *pLayerName, const VkInstanceCreateInfo *pCreateInfo, VL_LAYER_SETTING_LOG_CALLBACK pCallback) {
vk_layer_settings = std::make_unique<vl::LayerSettings>(pLayerName, pCreateInfo, pCallback);
VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VL_LAYER_SETTING_LOG_CALLBACK pCallback,
VlLayerSettingSet *pLayerSettingSet) {
(void)pAllocator;
vl::LayerSettings* layer_setting_set = new vl::LayerSettings(pLayerName, pCreateInfo, pAllocator, pCallback);
*pLayerSettingSet = (VlLayerSettingSet)layer_setting_set;
return VK_SUCCESS;
}
VkBool32 vlHasLayerSetting(const char *pSettingName) {
assert(vk_layer_settings);
void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
(void)pAllocator;
vl::LayerSettings *layer_setting_set = (vl::LayerSettings*)layerSettingSet;
delete layer_setting_set;
}
VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName) {
assert(layerSettingSet != VK_NULL_HANDLE);
assert(pSettingName);
assert(!std::string(pSettingName).empty());
const bool has_env_setting = vk_layer_settings->HasEnvSetting(pSettingName);
const bool has_file_setting = vk_layer_settings->HasFileSetting(pSettingName);
const bool has_api_setting = vk_layer_settings->HasAPISetting(pSettingName);
vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
const bool has_env_setting = layer_setting_set->HasEnvSetting(pSettingName);
const bool has_file_setting = layer_setting_set->HasFileSetting(pSettingName);
const bool has_api_setting = layer_setting_set->HasAPISetting(pSettingName);
return (has_env_setting || has_file_setting || has_api_setting) ? VK_TRUE : VK_FALSE;
}
VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT type, uint32_t *pValueCount, void *pValues) {
VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, VkLayerSettingTypeEXT type,
uint32_t *pValueCount, void *pValues) {
assert(pValueCount != nullptr);
if (!vk_layer_settings) {
if (layerSettingSet == VK_NULL_HANDLE) {
return VK_ERROR_INITIALIZATION_FAILED;
}
if (!vlHasLayerSetting(pSettingName)) {
if (!vlHasLayerSetting(layerSettingSet, pSettingName)) {
*pValueCount = 0;
return VK_SUCCESS;
}
@ -74,14 +92,16 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
return VK_ERROR_UNKNOWN;
}
vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
// First: search in the environment variables
const std::string &env_setting_list = vk_layer_settings->GetEnvSetting(pSettingName);
const std::string &env_setting_list = layer_setting_set->GetEnvSetting(pSettingName);
// Second: search in vk_layer_settings.txt
const std::string &file_setting_list = vk_layer_settings->GetFileSetting(pSettingName);
const std::string &file_setting_list = layer_setting_set->GetFileSetting(pSettingName);
// Third: search from VK_EXT_layer_settings usage
const vl::LayerSetting *api_setting = vk_layer_settings->GetAPISetting(pSettingName);
const vl::LayerSetting *api_setting = layer_setting_set->GetAPISetting(pSettingName);
// Environment variables overrides the values set by vk_layer_settings
const std::string setting_list = env_setting_list.empty() ? file_setting_list : env_setting_list;
@ -98,7 +118,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
switch (type) {
default: {
const std::string& message = vl::Format("Unknown VkLayerSettingTypeEXT `type` value: %d.", type);
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
return VK_ERROR_UNKNOWN;
}
case VK_LAYER_SETTING_TYPE_BOOL_EXT: {
@ -121,7 +141,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not a boolean value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -163,7 +183,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -205,7 +225,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -247,7 +267,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -289,7 +309,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -331,7 +351,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not a floating-point value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -373,7 +393,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not a floating-point value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -415,7 +435,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else {
const std::string &message =
vl::Format("The data provided (%s) is not a FrameSet value.", setting_value.c_str());
vk_layer_settings->Log(pSettingName, message.c_str());
layer_setting_set->Log(pSettingName, message.c_str());
}
}
} else {
@ -444,7 +464,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
VkResult result = VK_SUCCESS;
if (!settings.empty()) { // From env variable or setting file
std::vector<std::string> &settings_cache = vk_layer_settings->GetSettingCache(pSettingName);
std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
settings_cache = settings;
if (copy_values) {

11
tests/add_subdirectory/client.c
View file

@ -1,3 +1,12 @@
#include <vulkan/layer/vk_layer_settings.h>
VkBool32 foobar() { return vlHasLayerSetting("setting_key"); }
VkBool32 foobar() {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", NULL, NULL, NULL, &layerSettingSet);
VkBool32 result = vlHasLayerSetting(layerSettingSet, "setting_key") ? VK_TRUE : VK_FALSE;
vlDestroyLayerSettingSet(layerSettingSet, NULL);
return result;
}

224
tests/layer/test_setting_api.cpp
View file

@ -24,9 +24,13 @@
#include <vector>
TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
EXPECT_FALSE(vlHasLayerSetting("setting_key"));
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting_key"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
@ -45,13 +49,12 @@ TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlHasLayerSetting) {
@ -136,22 +139,21 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
layer_settings_create_info.settingCount = static_cast<uint32_t>(settings.size());
layer_settings_create_info.pSettings = &settings[0];
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
// The expected layer code side:
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_FALSE(vlHasLayerSetting("setting0"));
EXPECT_TRUE(vlHasLayerSetting("bool_value"));
EXPECT_TRUE(vlHasLayerSetting("int32_value"));
EXPECT_TRUE(vlHasLayerSetting("int64_value"));
EXPECT_TRUE(vlHasLayerSetting("uint32_value"));
EXPECT_TRUE(vlHasLayerSetting("uint64_value"));
EXPECT_TRUE(vlHasLayerSetting("float_value"));
EXPECT_TRUE(vlHasLayerSetting("double_value"));
EXPECT_TRUE(vlHasLayerSetting("frameset_value"));
EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting0"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "bool_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int32_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int64_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint32_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint64_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "float_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "double_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "frameset_value"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
@ -163,34 +165,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
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(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
@ -202,34 +206,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
@ -241,34 +247,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
@ -281,34 +289,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
@ -321,34 +331,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, &values[0]);
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(76, values[0]);
EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
@ -361,33 +373,35 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<float> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
@ -400,33 +414,35 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<double> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
@ -441,23 +457,22 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count);
@ -465,7 +480,8 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
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);
@ -474,6 +490,8 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(100, values[1].count);
EXPECT_EQ(1, values[1].step);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
@ -485,32 +503,34 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = &layer_settings_create_info;
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr);
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<const char*> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ(nullptr, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
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);
}

163
tests/layer/test_setting_file.cpp
View file

@ -23,218 +23,262 @@
#include "vulkan/layer/vk_layer_settings.h"
#include <vector>
void test_helper_SetLayerSetting(const char* pSettingName, const char* pValue);
void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue);
TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "true,false");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "true,false");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
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(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76,-82");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76,-82");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76,82");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76,82");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, &values[0]);
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(76, values[0]);
EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76.1f,-82.5f");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1f,-82.5f");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<float> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76.1,-82.5");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1,-82.5");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<double> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
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);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "76-100-10,1-100-1");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76-100-10,1-100-1");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -242,7 +286,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count);
@ -250,7 +294,8 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &values[0]);
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);
@ -259,33 +304,41 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(100, values[1].count);
EXPECT_EQ(1, values[1].step);
EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
vlInitLayerSettings("VK_LAYER_LUNARG_test", nullptr, nullptr);
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting("lunarg_test.my_setting", "VALUE_A,VALUE_B");
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "VALUE_A,VALUE_B");
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0;
VkResult result_count = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr);
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<const char*> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ(nullptr, values[1]);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete = vlGetLayerSettingValues("my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]);
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);
}