eden-emu/Vulkan-Utility-Libraries
17
0
Fork 0
Code Issues Pull requests 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" #include "vk_layer_settings_ext.h"
VK_DEFINE_HANDLE(VlLayerSettingSet)
typedef void *(*VL_LAYER_SETTING_LOG_CALLBACK)(const char *pSettingName, const char *pMessage); 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. // Create a layer setting set. 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); 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 // 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 // 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 #ifdef __cplusplus
} }

6
src/layer/layer_settings_manager.cpp
View file

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

5
src/layer/layer_settings_manager.hpp
View file

@ -47,7 +47,8 @@ namespace vl {
class LayerSettings { class LayerSettings {
public: 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(); ~LayerSettings();
bool HasEnvSetting(const char *pSettingName); bool HasEnvSetting(const char *pSettingName);
@ -81,7 +82,7 @@ namespace vl {
void ParseSettingsFile(const char *filename); void ParseSettingsFile(const char *filename);
std::string layer_name; std::string layer_name;
const VkLayerSettingsCreateInfoEXT *create_info; const VkLayerSettingsCreateInfoEXT *create_info{nullptr};
VL_LAYER_SETTING_LOG_CALLBACK callback{nullptr}; VL_LAYER_SETTING_LOG_CALLBACK callback{nullptr};
}; };
}// namespace vl }// namespace vl

76
src/layer/vk_layer_settings.cpp
View file

@ -32,40 +32,58 @@
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
static std::unique_ptr<vl::LayerSettings> 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) {
void test_helper_SetLayerSetting(const char *pSettingName, const char* pValue) { assert(layerSettingSet != VK_NULL_HANDLE);
assert(vk_layer_settings);
assert(pSettingName != nullptr); assert(pSettingName != nullptr);
assert(pValue != 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) { VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
vk_layer_settings = std::make_unique<vl::LayerSettings>(pLayerName, pCreateInfo, pCallback); 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) { void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
assert(vk_layer_settings); (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(pSettingName);
assert(!std::string(pSettingName).empty()); assert(!std::string(pSettingName).empty());
const bool has_env_setting = vk_layer_settings->HasEnvSetting(pSettingName); vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
const bool has_file_setting = vk_layer_settings->HasFileSetting(pSettingName);
const bool has_api_setting = vk_layer_settings->HasAPISetting(pSettingName); 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; 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); assert(pValueCount != nullptr);
if (!vk_layer_settings) { if (layerSettingSet == VK_NULL_HANDLE) {
return VK_ERROR_INITIALIZATION_FAILED; return VK_ERROR_INITIALIZATION_FAILED;
} }
if (!vlHasLayerSetting(pSettingName)) { if (!vlHasLayerSetting(layerSettingSet, pSettingName)) {
*pValueCount = 0; *pValueCount = 0;
return VK_SUCCESS; return VK_SUCCESS;
} }
@ -74,14 +92,16 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
return VK_ERROR_UNKNOWN; return VK_ERROR_UNKNOWN;
} }
vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
// First: search in the environment variables // 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 // 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 // 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 // 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; 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) { switch (type) {
default: { default: {
const std::string& message = vl::Format("Unknown VkLayerSettingTypeEXT `type` value: %d.", type); 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; return VK_ERROR_UNKNOWN;
} }
case VK_LAYER_SETTING_TYPE_BOOL_EXT: { case VK_LAYER_SETTING_TYPE_BOOL_EXT: {
@ -121,7 +141,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not a boolean value.", setting_value.c_str()); 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 { } else {
@ -163,7 +183,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str()); 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 { } else {
@ -205,7 +225,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str()); 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 { } else {
@ -247,7 +267,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str()); 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 { } else {
@ -289,7 +309,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not an integer value.", setting_value.c_str()); 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 { } else {
@ -331,7 +351,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not a floating-point value.", setting_value.c_str()); 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 { } else {
@ -373,7 +393,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not a floating-point value.", setting_value.c_str()); 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 { } else {
@ -415,7 +435,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
} else { } else {
const std::string &message = const std::string &message =
vl::Format("The data provided (%s) is not a FrameSet value.", setting_value.c_str()); 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 { } else {
@ -444,7 +464,7 @@ VkResult vlGetLayerSettingValues(const char *pSettingName, VkLayerSettingTypeEXT
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
if (!settings.empty()) { // From env variable or setting file 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; settings_cache = settings;
if (copy_values) { if (copy_values) {

11
tests/add_subdirectory/client.c
View file

@ -1,3 +1,12 @@
#include <vulkan/layer/vk_layer_settings.h> #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> #include <vector>
TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) { 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) { TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
@ -45,13 +49,12 @@ TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
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) { 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.settingCount = static_cast<uint32_t>(settings.size());
layer_settings_create_info.pSettings = &settings[0]; 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: // 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_FALSE(vlHasLayerSetting(layerSettingSet, "setting0"));
EXPECT_TRUE(vlHasLayerSetting("bool_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "bool_value"));
EXPECT_TRUE(vlHasLayerSetting("int32_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int32_value"));
EXPECT_TRUE(vlHasLayerSetting("int64_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int64_value"));
EXPECT_TRUE(vlHasLayerSetting("uint32_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint32_value"));
EXPECT_TRUE(vlHasLayerSetting("uint64_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint64_value"));
EXPECT_TRUE(vlHasLayerSetting("float_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "float_value"));
EXPECT_TRUE(vlHasLayerSetting("double_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "double_value"));
EXPECT_TRUE(vlHasLayerSetting("frameset_value")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "frameset_value"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
@ -163,34 +165,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkBool32> values(static_cast<uint32_t>(value_count)); std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
@ -202,34 +206,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 2; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::int32_t> values(static_cast<uint32_t>(value_count)); std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(-82, values[1]); EXPECT_EQ(-82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
@ -241,34 +247,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 2; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::int64_t> values(static_cast<uint32_t>(value_count)); std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(-82, values[1]); EXPECT_EQ(-82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
@ -281,34 +289,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count)); std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
@ -321,34 +331,36 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count)); std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
@ -361,33 +373,35 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<float> values(static_cast<uint32_t>(value_count)); std::vector<float> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
@ -400,33 +414,35 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<double> values(static_cast<uint32_t>(value_count)); std::vector<double> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
@ -441,23 +457,22 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkFrameset> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count); EXPECT_EQ(100, values[0].count);
@ -465,7 +480,8 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count); 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(100, values[1].count);
EXPECT_EQ(1, values[1].step); EXPECT_EQ(1, values[1].step);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_String) { TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
@ -485,32 +503,34 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VkInstanceCreateInfo instance_create_info{}; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
instance_create_info.pNext = &layer_settings_create_info;
vlInitLayerSettings("VK_LAYER_LUNARG_test", &instance_create_info, nullptr); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
EXPECT_TRUE(vlHasLayerSetting("my_setting"));
uint32_t value_count = 0; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<const char*> values(static_cast<uint32_t>(value_count)); std::vector<const char*> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ(nullptr, values[1]); EXPECT_STREQ(nullptr, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ("VALUE_B", values[1]); EXPECT_STREQ("VALUE_B", values[1]);
EXPECT_EQ(2, value_count); 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 "vulkan/layer/vk_layer_settings.h"
#include <vector> #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) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkBool32> values(static_cast<uint32_t>(value_count)); std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::int32_t> values(static_cast<uint32_t>(value_count)); std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(-82, values[1]); EXPECT_EQ(-82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::int64_t> values(static_cast<uint32_t>(value_count)); std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(-82, values[1]); EXPECT_EQ(-82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count)); std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count)); std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
value_count = 1; 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(0, values[1]); EXPECT_EQ(0, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<float> values(static_cast<uint32_t>(value_count)); std::vector<float> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<double> values(static_cast<uint32_t>(value_count)); std::vector<double> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -242,7 +286,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
value_count = 1; value_count = 1;
VkResult result_incomplete = 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(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count); EXPECT_EQ(100, values[0].count);
@ -250,7 +294,8 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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(VK_SUCCESS, result_complete);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count); 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(100, values[1].count);
EXPECT_EQ(1, values[1].step); EXPECT_EQ(1, values[1].step);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_String) { 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; 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(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<const char*> values(static_cast<uint32_t>(value_count)); std::vector<const char*> values(static_cast<uint32_t>(value_count));
value_count = 1; 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_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ(nullptr, values[1]); EXPECT_STREQ(nullptr, values[1]);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; 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_EQ(VK_SUCCESS, result_complete);
EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_A", values[0]);
EXPECT_STREQ("VALUE_B", values[1]); EXPECT_STREQ("VALUE_B", values[1]);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }