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

Ensure consistent usage of vku in PUBLIC header files

Browse source 
closes #107
This commit is contained in:
Juan Ramos 2023-09-19 13:00:52 -06:00 • committed by Juan Ramos
parent 9527ed588f
commit fefcc37fc1
15 changed files with 642 additions and 659 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -15,20 +15,20 @@ extern "C" {
#include "vk_layer_settings_ext.h" #include "vk_layer_settings_ext.h"
typedef enum VlLayerSettingType { typedef enum VkuLayerSettingType {
VL_LAYER_SETTING_TYPE_BOOL32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT, VKU_LAYER_SETTING_TYPE_BOOL32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT,
VL_LAYER_SETTING_TYPE_INT32 = VK_LAYER_SETTING_TYPE_INT32_EXT, VKU_LAYER_SETTING_TYPE_INT32 = VK_LAYER_SETTING_TYPE_INT32_EXT,
VL_LAYER_SETTING_TYPE_INT64 = VK_LAYER_SETTING_TYPE_INT64_EXT, VKU_LAYER_SETTING_TYPE_INT64 = VK_LAYER_SETTING_TYPE_INT64_EXT,
VL_LAYER_SETTING_TYPE_UINT32 = VK_LAYER_SETTING_TYPE_UINT32_EXT, VKU_LAYER_SETTING_TYPE_UINT32 = VK_LAYER_SETTING_TYPE_UINT32_EXT,
VL_LAYER_SETTING_TYPE_UINT64 = VK_LAYER_SETTING_TYPE_UINT64_EXT, VKU_LAYER_SETTING_TYPE_UINT64 = VK_LAYER_SETTING_TYPE_UINT64_EXT,
VL_LAYER_SETTING_TYPE_FLOAT32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT, VKU_LAYER_SETTING_TYPE_FLOAT32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT,
VL_LAYER_SETTING_TYPE_FLOAT64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT, VKU_LAYER_SETTING_TYPE_FLOAT64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT,
VL_LAYER_SETTING_TYPE_STRING = VK_LAYER_SETTING_TYPE_STRING_EXT, VKU_LAYER_SETTING_TYPE_STRING = VK_LAYER_SETTING_TYPE_STRING_EXT,
VL_LAYER_SETTING_TYPE_FRAMESET, VKU_LAYER_SETTING_TYPE_FRAMESET,
VL_LAYER_SETTING_TYPE_FRAMESET_STRING VKU_LAYER_SETTING_TYPE_FRAMESET_STRING
} VlLayerSettingType; } VkuLayerSettingType;
VK_DEFINE_HANDLE(VlLayerSettingSet) VK_DEFINE_HANDLE(VkuLayerSettingSet)
// - `first` is an integer related to the first frame to be processed. // - `first` is an integer related to the first frame to be processed.
// The frame numbering is 0-based. // The frame numbering is 0-based.
@ -38,37 +38,37 @@ VK_DEFINE_HANDLE(VlLayerSettingSet)
// represent no frame to be processed. // represent no frame to be processed.
// between frames to be processed. // between frames to be processed.
typedef struct VlFrameset { typedef struct VkuFrameset {
uint32_t first; uint32_t first;
uint32_t count; uint32_t count;
uint32_t step; uint32_t step;
} VlFrameset; } VkuFrameset;
typedef void (VKAPI_PTR *VlLayerSettingLogCallback)(const char *pSettingName, const char *pMessage); typedef void(VKAPI_PTR *VkuLayerSettingLogCallback)(const char *pSettingName, const char *pMessage);
// Create a layer setting set. 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.
VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo, VkResult vkuCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback, const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback,
VlLayerSettingSet *pLayerSettingSet); VkuLayerSettingSet *pLayerSettingSet);
void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator); void vkuDestroyLayerSettingSet(VkuLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator);
// Set a compatibility namespace to find layer settings using environment variables // Set a compatibility namespace to find layer settings using environment variables
void vlSetLayerSettingCompatibilityNamespace(VlLayerSettingSet layerSettingSet, const char *name); void vkuSetLayerSettingCompatibilityNamespace(VkuLayerSettingSet layerSettingSet, const char *name);
// 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(VlLayerSettingSet layerSettingSet, const char *pSettingName); VkBool32 vkuHasLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName);
// Query setting values // Query setting values
VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, VlLayerSettingType type, VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuLayerSettingType type,
uint32_t *pValueCount, void *pValues); uint32_t *pValueCount, void *pValues);
// Find the VkLayerSettingsCreateInfoEXT in the VkInstanceCreateInfo pNext chain, return NULL if not present // Find the VkLayerSettingsCreateInfoEXT in the VkInstanceCreateInfo pNext chain, return NULL if not present
const VkLayerSettingsCreateInfoEXT *vlFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo); const VkLayerSettingsCreateInfoEXT *vkuFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo);
// Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT
VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings, VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
uint32_t *pUnknownSettingCount, const char **pUnknownSettings); uint32_t *pUnknownSettingCount, const char **pUnknownSettings);
#ifdef __cplusplus #ifdef __cplusplus
} }

67
include/vulkan/layer/vk_layer_settings.hpp
View file

@ -13,67 +13,50 @@
#include <vector> #include <vector>
#include <string> #include <string>
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
const char *pSettingName, bool &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
const char *pSettingName, std::vector <bool> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
const char *pSettingName, int32_t &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues);
const char *pSettingName, std::vector<int32_t> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
const char *pSettingName, int64_t &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues);
const char *pSettingName, std::vector<int64_t> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
const char *pSettingName, uint32_t &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues);
const char *pSettingName, std::vector<uint32_t> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
const char *pSettingName, uint64_t &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues);
const char *pSettingName, std::vector<uint64_t> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
const char *pSettingName, float &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
const char *pSettingName, std::vector<float> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
const char *pSettingName, double &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
const char *pSettingName, std::vector<double> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
const char *pSettingName, std::string &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
const char *pSettingName, std::vector<std::string> &settingValues); std::vector<std::string> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
const char *pSettingName, VlFrameset &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
const char *pSettingName, std::vector<VlFrameset> &settingValues); std::vector<VkuFrameset> &settingValues);
// Required by vk_safe_struct // Required by vk_safe_struct
typedef std::pair<uint32_t, uint32_t> VlCustomSTypeInfo; typedef std::pair<uint32_t, uint32_t> VkuCustomSTypeInfo;
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
const char *pSettingName, std::vector<VkuCustomSTypeInfo> &settingValues);
std::vector<VlCustomSTypeInfo> &settingValues);
// Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT
VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings, VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
std::vector<const char *>& unknownSettings); std::vector<const char *> &unknownSettings);

2
src/layer/layer_settings_manager.cpp
View file

@ -101,7 +101,7 @@ static void AddWorkaroundLayerNames(std::vector<std::string> &layer_names) {
namespace vl { namespace vl {
LayerSettings::LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo, LayerSettings::LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback) const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback)
: layer_name(pLayerName) : layer_name(pLayerName)
, create_info(pCreateInfo) , create_info(pCreateInfo)
, pCallback(pCallback) { , pCallback(pCallback) {

4
src/layer/layer_settings_manager.hpp
View file

@ -19,7 +19,7 @@ namespace vl {
class LayerSettings { class LayerSettings {
public: public:
LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo, LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback); const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback);
~LayerSettings(); ~LayerSettings();
void SetPrefix(const char *pPrefix) { this->prefix = pPrefix; } void SetPrefix(const char *pPrefix) { this->prefix = pPrefix; }
@ -57,7 +57,7 @@ namespace vl {
std::string prefix; std::string prefix;
std::string layer_name; std::string layer_name;
const VkLayerSettingsCreateInfoEXT *create_info{nullptr}; const VkLayerSettingsCreateInfoEXT *create_info{nullptr};
VlLayerSettingLogCallback pCallback{nullptr}; VkuLayerSettingLogCallback pCallback{nullptr};
}; };
}// namespace vl }// namespace vl

8
src/layer/layer_settings_util.cpp
View file

@ -209,10 +209,10 @@ int64_t ToInt64(const std::string &token) {
return int_id; return int_id;
} }
VlFrameset ToFrameSet(const std::string &s) { VkuFrameset ToFrameSet(const std::string &s) {
assert(IsFrameSets(s)); assert(IsFrameSets(s));
VlFrameset frameset{0, 1, 1}; VkuFrameset frameset{0, 1, 1};
const std::vector<std::string> &frameset_split = vl::Split(s, '-'); const std::vector<std::string> &frameset_split = vl::Split(s, '-');
if (frameset_split.size() >= 1) { if (frameset_split.size() >= 1) {
@ -228,10 +228,10 @@ VlFrameset ToFrameSet(const std::string &s) {
return frameset; return frameset;
} }
std::vector<VlFrameset> ToFrameSets(const std::string &s) { std::vector<VkuFrameset> ToFrameSets(const std::string &s) {
std::vector<std::string> tokens = Split(s, FindDelimiter(s)); std::vector<std::string> tokens = Split(s, FindDelimiter(s));
std::vector<VlFrameset> results; std::vector<VkuFrameset> results;
results.resize(tokens.size()); results.resize(tokens.size());
for (std::size_t i = 0, n = tokens.size(); i < n; ++i) { for (std::size_t i = 0, n = tokens.size(); i < n; ++i) {
results[i] = ToFrameSet(tokens[i]); results[i] = ToFrameSet(tokens[i]);

4
src/layer/layer_settings_util.hpp
View file

@ -62,9 +62,9 @@ namespace vl {
bool IsFrameSets(const std::string &s); bool IsFrameSets(const std::string &s);
VlFrameset ToFrameSet(const std::string &s); VkuFrameset ToFrameSet(const std::string &s);
std::vector<VlFrameset> ToFrameSets(const std::string &s); std::vector<VkuFrameset> ToFrameSets(const std::string &s);
bool IsInteger(const std::string &s); bool IsInteger(const std::string &s);

76
src/layer/vk_layer_settings.cpp
View file

@ -20,7 +20,7 @@
#include <unordered_map> #include <unordered_map>
// This is used only for unit tests in test_layer_setting_file // 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(VkuLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue) {
assert(layerSettingSet != VK_NULL_HANDLE); assert(layerSettingSet != VK_NULL_HANDLE);
assert(pSettingName != nullptr); assert(pSettingName != nullptr);
assert(pValue != nullptr); assert(pValue != nullptr);
@ -30,31 +30,31 @@ void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *
layer_setting_set->SetFileSetting(pSettingName, pValue); layer_setting_set->SetFileSetting(pSettingName, pValue);
} }
VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo, VkResult vkuCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback, const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback,
VlLayerSettingSet *pLayerSettingSet) { VkuLayerSettingSet *pLayerSettingSet) {
(void)pAllocator; (void)pAllocator;
vl::LayerSettings* layer_setting_set = new vl::LayerSettings(pLayerName, pCreateInfo, pAllocator, pCallback); vl::LayerSettings* layer_setting_set = new vl::LayerSettings(pLayerName, pCreateInfo, pAllocator, pCallback);
*pLayerSettingSet = (VlLayerSettingSet)layer_setting_set; *pLayerSettingSet = (VkuLayerSettingSet)layer_setting_set;
return VK_SUCCESS; return VK_SUCCESS;
} }
void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) { void vkuDestroyLayerSettingSet(VkuLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
(void)pAllocator; (void)pAllocator;
vl::LayerSettings *layer_setting_set = (vl::LayerSettings*)layerSettingSet; vl::LayerSettings *layer_setting_set = (vl::LayerSettings*)layerSettingSet;
delete layer_setting_set; delete layer_setting_set;
} }
void vlSetLayerSettingCompatibilityNamespace(VlLayerSettingSet layerSettingSet, const char *prefixName) { void vkuSetLayerSettingCompatibilityNamespace(VkuLayerSettingSet layerSettingSet, const char *prefixName) {
vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet; vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
layer_setting_set->SetPrefix(prefixName); layer_setting_set->SetPrefix(prefixName);
} }
VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName) { VkBool32 vkuHasLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName) {
assert(layerSettingSet != VK_NULL_HANDLE); assert(layerSettingSet != VK_NULL_HANDLE);
assert(pSettingName); assert(pSettingName);
assert(!std::string(pSettingName).empty()); assert(!std::string(pSettingName).empty());
@ -68,7 +68,7 @@ VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSetti
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(VlLayerSettingSet layerSettingSet, const char *pSettingName, VlLayerSettingType type, VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuLayerSettingType type,
uint32_t *pValueCount, void *pValues) { uint32_t *pValueCount, void *pValues) {
assert(pValueCount != nullptr); assert(pValueCount != nullptr);
@ -76,7 +76,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return VK_ERROR_INITIALIZATION_FAILED; return VK_ERROR_INITIALIZATION_FAILED;
} }
if (!vlHasLayerSetting(layerSettingSet, pSettingName)) { if (!vkuHasLayerSetting(layerSettingSet, pSettingName)) {
*pValueCount = 0; *pValueCount = 0;
return VK_SUCCESS; return VK_SUCCESS;
} }
@ -114,7 +114,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
layer_setting_set->Log(pSettingName, message.c_str()); layer_setting_set->Log(pSettingName, message.c_str());
return VK_ERROR_UNKNOWN; return VK_ERROR_UNKNOWN;
} }
case VL_LAYER_SETTING_TYPE_BOOL32: { case VKU_LAYER_SETTING_TYPE_BOOL32: {
std::vector<VkBool32> values; std::vector<VkBool32> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -143,7 +143,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -163,7 +163,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_INT32: { case VKU_LAYER_SETTING_TYPE_INT32: {
std::vector<std::int32_t> values; std::vector<std::int32_t> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -188,7 +188,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -208,7 +208,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_INT64: { case VKU_LAYER_SETTING_TYPE_INT64: {
std::vector<std::int64_t> values; std::vector<std::int64_t> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -233,7 +233,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -253,7 +253,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_UINT32: { case VKU_LAYER_SETTING_TYPE_UINT32: {
std::vector<std::uint32_t> values; std::vector<std::uint32_t> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -278,7 +278,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -298,7 +298,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_UINT64: { case VKU_LAYER_SETTING_TYPE_UINT64: {
std::vector<std::uint64_t> values; std::vector<std::uint64_t> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -323,7 +323,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -343,7 +343,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_FLOAT32: { case VKU_LAYER_SETTING_TYPE_FLOAT32: {
std::vector<float> values; std::vector<float> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -368,7 +368,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -388,7 +388,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_FLOAT64: { case VKU_LAYER_SETTING_TYPE_FLOAT64: {
std::vector<double> values; std::vector<double> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -413,7 +413,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
if (static_cast<VlLayerSettingType>(api_setting->type) != type) { if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
if (*pValueCount < api_setting->count) { if (*pValueCount < api_setting->count) {
@ -433,8 +433,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_FRAMESET: { case VKU_LAYER_SETTING_TYPE_FRAMESET: {
std::vector<VlFrameset> values; std::vector<VkuFrameset> values;
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
@ -458,7 +458,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
*pValueCount = static_cast<std::uint32_t>(settings.size()); *pValueCount = static_cast<std::uint32_t>(settings.size());
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
const uint32_t frameset_count = static_cast<uint32_t>(api_setting->count / (sizeof(VlFrameset) / sizeof(VlFrameset::count))); const uint32_t frameset_count = static_cast<uint32_t>(api_setting->count / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
if (api_setting->type != VK_LAYER_SETTING_TYPE_UINT32_EXT) { if (api_setting->type != VK_LAYER_SETTING_TYPE_UINT32_EXT) {
result = VK_ERROR_FORMAT_NOT_SUPPORTED; result = VK_ERROR_FORMAT_NOT_SUPPORTED;
} else if (copy_values) { } else if (copy_values) {
@ -466,7 +466,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t count = std::min(*pValueCount, frameset_count); const std::uint32_t count = std::min(*pValueCount, frameset_count);
const VlFrameset *data = static_cast<const VlFrameset *>(api_setting->pValues); const VkuFrameset *data = static_cast<const VkuFrameset *>(api_setting->pValues);
values.assign(data, data + count); values.assign(data, data + count);
} else { } else {
*pValueCount = frameset_count; *pValueCount = frameset_count;
@ -474,12 +474,12 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
} }
if (copy_values) { if (copy_values) {
std::copy(values.begin(), values.end(), reinterpret_cast<VlFrameset *>(pValues)); std::copy(values.begin(), values.end(), reinterpret_cast<VkuFrameset *>(pValues));
} }
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_STRING: { case VKU_LAYER_SETTING_TYPE_STRING: {
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName); std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
@ -561,7 +561,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VL_LAYER_SETTING_TYPE_FRAMESET_STRING: { case VKU_LAYER_SETTING_TYPE_FRAMESET_STRING: {
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName); std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
@ -578,7 +578,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
} }
} else if (api_setting != nullptr) { // From Vulkan Layer Setting API } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
const std::uint32_t frameset_count = const std::uint32_t frameset_count =
static_cast<uint32_t>(api_setting->count / (sizeof(VlFrameset) / sizeof(VlFrameset::count))); static_cast<uint32_t>(api_setting->count / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
if (copy_values) { if (copy_values) {
if (*pValueCount < frameset_count) { if (*pValueCount < frameset_count) {
@ -595,7 +595,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
break; break;
case VK_LAYER_SETTING_TYPE_UINT32_EXT: case VK_LAYER_SETTING_TYPE_UINT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
const VlFrameset *asFramesets = static_cast<const VlFrameset *>(api_setting->pValues); const VkuFrameset *asFramesets = static_cast<const VkuFrameset *>(api_setting->pValues);
settings_cache[i] = vl::FormatString("%d-%d-%d", settings_cache[i] = vl::FormatString("%d-%d-%d",
asFramesets[i].first, asFramesets[i].count, asFramesets[i].step); asFramesets[i].first, asFramesets[i].count, asFramesets[i].step);
} }
@ -620,7 +620,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
} }
} }
const VkLayerSettingsCreateInfoEXT *vlFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo) { const VkLayerSettingsCreateInfoEXT *vkuFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo) {
const VkBaseOutStructure *current = reinterpret_cast<const VkBaseOutStructure *>(pCreateInfo); const VkBaseOutStructure *current = reinterpret_cast<const VkBaseOutStructure *>(pCreateInfo);
const VkLayerSettingsCreateInfoEXT *found = nullptr; const VkLayerSettingsCreateInfoEXT *found = nullptr;
while (current) { while (current) {
@ -644,7 +644,7 @@ static bool vlHasSetting(uint32_t settingsCount, const char **pSettings, const c
return false; return false;
} }
VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings, VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
uint32_t* pUnknownSettingCount, const char** pUnknownSettings) { uint32_t* pUnknownSettingCount, const char** pUnknownSettings) {
assert(pUnknownSettingCount != nullptr); assert(pUnknownSettingCount != nullptr);
@ -672,15 +672,15 @@ VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, u
return VK_SUCCESS; return VK_SUCCESS;
} }
VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings, VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
std::vector<const char*>& unknownSettings) { std::vector<const char*>& unknownSettings) {
uint32_t unknown_setting_count = 0; uint32_t unknown_setting_count = 0;
VkResult result = vlGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr); VkResult result = vkuGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr);
if (unknown_setting_count > 0) { if (unknown_setting_count > 0) {
unknownSettings.resize(unknown_setting_count); unknownSettings.resize(unknown_setting_count);
result = vlGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, &unknownSettings[0]); result = vkuGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, &unknownSettings[0]);
} }
return result; return result;

102
src/layer/vk_layer_settings_helper.cpp
View file

@ -21,136 +21,136 @@ static std::string Merge(const std::vector<std::string> &strings) {
return result; return result;
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
VkBool32 pValues; VkBool32 pValues;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
settingValue = pValues == VK_TRUE; settingValue = pValues == VK_TRUE;
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
std::vector<VkBool32> values(value_count); std::vector<VkBool32> values(value_count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
for (std::size_t i = 0, n = values.size(); i < n; ++i) { for (std::size_t i = 0, n = values.size(); i < n; ++i) {
settingValues.push_back(values[i] == VK_TRUE); settingValues.push_back(values[i] == VK_TRUE);
} }
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
std::vector<std::string> values; std::vector<std::string> values;
vlGetLayerSettingValues(layerSettingSet, pSettingName, values); vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
settingValue = Merge(values); settingValue = Merge(values);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<std::string> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<std::string> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
std::vector<const char *> values(value_count); std::vector<const char *> values(value_count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
settingValues.assign(values.begin(), values.end()); settingValues.assign(values.begin(), values.end());
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VlFrameset& settingValue) { void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char* pSettingName, VkuFrameset& settingValue) {
uint32_t value_count = sizeof(VlFrameset) / sizeof(VlFrameset::count); uint32_t value_count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VlFrameset> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkuFrameset> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VlFrameset) / sizeof(VlFrameset::count))); settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
} }
} }
@ -164,7 +164,7 @@ static uint32_t TokenToUint(const std::string &token) {
return int_id; return int_id;
} }
static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vector<VlCustomSTypeInfo>& custom_stype_info) { static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vector<VkuCustomSTypeInfo>& custom_stype_info) {
// List format is a list of integer pairs // List format is a list of integer pairs
for (std::size_t i = 0, n = raw_id_list.size(); i < n; i += 2) { for (std::size_t i = 0, n = raw_id_list.size(); i < n; i += 2) {
uint32_t stype_id = TokenToUint(raw_id_list[i + 0]); uint32_t stype_id = TokenToUint(raw_id_list[i + 0]);
@ -184,12 +184,12 @@ static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vecto
} }
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VlCustomSTypeInfo> &settingValues) { void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkuCustomSTypeInfo> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
std::vector<const char *> values(value_count); std::vector<const char *> values(value_count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
SetCustomStypeInfo(values, settingValues); SetCustomStypeInfo(values, settingValues);
} }
} }

8
tests/add_subdirectory/vk_layer_settings.c
View file

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

200
tests/layer/test_setting_api.cpp
View file

@ -10,17 +10,17 @@
#include "vulkan/layer/vk_layer_settings.h" #include "vulkan/layer/vk_layer_settings.h"
TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) { TEST(test_layer_setting_api, vkuHasLayerSetting_NotFound) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting_key")); EXPECT_FALSE(vkuHasLayerSetting(layerSettingSet, "setting_key"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlHasLayerSetting_Found) { TEST(test_layer_setting_api, vkuHasLayerSetting_Found) {
std::int32_t pValues = 76; std::int32_t pValues = 76;
VkLayerSettingEXT my_setting; VkLayerSettingEXT my_setting;
@ -36,15 +36,15 @@ TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlHasLayerSetting) { TEST(test_layer_setting_api, vkuHasLayerSetting) {
// The expected application code side: // The expected application code side:
std::vector<VkLayerSettingEXT> settings; std::vector<VkLayerSettingEXT> settings;
@ -111,13 +111,13 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_double_value.count = 1; setting_double_value.count = 1;
settings.push_back(setting_double_value); settings.push_back(setting_double_value);
VlFrameset value_frameset{76, 100, 10}; VkuFrameset value_frameset{76, 100, 10};
VkLayerSettingEXT setting_frameset_value{}; VkLayerSettingEXT setting_frameset_value{};
setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_frameset_value.pSettingName = "frameset_value"; setting_frameset_value.pSettingName = "frameset_value";
setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT; setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
setting_frameset_value.pValues = &value_frameset; setting_frameset_value.pValues = &value_frameset;
setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count); setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
settings.push_back(setting_frameset_value); settings.push_back(setting_frameset_value);
VkLayerSettingsCreateInfoEXT layer_settings_create_info; VkLayerSettingsCreateInfoEXT layer_settings_create_info;
@ -127,23 +127,23 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
layer_settings_create_info.pSettings = &settings[0]; layer_settings_create_info.pSettings = &settings[0];
// The expected layer code side: // The expected layer code side:
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting0")); EXPECT_FALSE(vkuHasLayerSetting(layerSettingSet, "setting0"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "bool_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "bool_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int32_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "int32_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int64_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "int64_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint32_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "uint32_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint64_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "uint64_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "float_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "float_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "double_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "double_value"));
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "frameset_value")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "frameset_value"));
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE}; std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -152,14 +152,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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);
@ -167,7 +167,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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]);
@ -175,16 +175,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82}; std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -193,14 +193,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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);
@ -208,7 +208,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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]);
@ -216,16 +216,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82}; std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -234,14 +234,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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);
@ -249,7 +249,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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]);
@ -257,16 +257,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82}; std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -276,14 +276,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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);
@ -291,7 +291,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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]);
@ -299,16 +299,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82}; std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -318,14 +318,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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);
@ -333,7 +333,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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]);
@ -341,16 +341,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f}; std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -360,14 +360,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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);
@ -375,23 +375,23 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5}; std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -401,14 +401,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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);
@ -416,28 +416,28 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
const VlFrameset input_values[] = { const VkuFrameset input_values[] = {
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
const std::uint32_t frameset_count = const std::uint32_t frameset_count =
static_cast<std::uint32_t>(std::size(input_values) * (sizeof(VlFrameset) / sizeof(VlFrameset::count))); static_cast<std::uint32_t>(std::size(input_values) * (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, frameset_count, input_values} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, frameset_count, input_values}
@ -446,22 +446,22 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<std::uint32_t>(std::size(settings)), settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<std::uint32_t>(std::size(settings)), settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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<VlFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -470,7 +470,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -480,10 +480,10 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_String) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"}; std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
@ -492,14 +492,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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);
@ -507,7 +507,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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]);
@ -515,11 +515,11 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }

132
tests/layer/test_setting_cast.cpp
View file

@ -12,7 +12,7 @@
#include <vector> #include <vector>
#include <cstring> #include <cstring>
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE}; std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -21,16 +21,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VkBool32> values(input_values.size()); std::vector<VkBool32> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
@ -39,16 +39,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("true", string_values[0]); EXPECT_STREQ("true", string_values[0]);
EXPECT_STREQ("false", string_values[1]); EXPECT_STREQ("false", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82}; std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -57,16 +57,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::int32_t> values(input_values.size()); std::vector<std::int32_t> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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]);
@ -75,16 +75,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("76", string_values[0]); EXPECT_STREQ("76", string_values[0]);
EXPECT_STREQ("-82", string_values[1]); EXPECT_STREQ("-82", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82}; std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -93,16 +93,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::int64_t> values(input_values.size()); std::vector<std::int64_t> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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]);
@ -111,16 +111,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("76", string_values[0]); EXPECT_STREQ("76", string_values[0]);
EXPECT_STREQ("-82", string_values[1]); EXPECT_STREQ("-82", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82}; std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -130,16 +130,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::uint32_t> values(input_values.size()); std::vector<std::uint32_t> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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]);
@ -148,16 +148,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("76", string_values[0]); EXPECT_STREQ("76", string_values[0]);
EXPECT_STREQ("82", string_values[1]); EXPECT_STREQ("82", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82}; std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -167,16 +167,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::uint64_t> values(input_values.size()); std::vector<std::uint64_t> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
@ -185,16 +185,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("76", string_values[0]); EXPECT_STREQ("76", string_values[0]);
EXPECT_STREQ("82", string_values[1]); EXPECT_STREQ("82", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f}; std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -204,16 +204,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<float> values(input_values.size()); std::vector<float> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
@ -222,16 +222,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr); EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5}; std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
@ -241,16 +241,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<double> values(input_values.size()); std::vector<double> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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);
@ -259,19 +259,19 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr); EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
const std::size_t frameset_size = (sizeof(VlFrameset) / sizeof(VlFrameset::count)); const std::size_t frameset_size = (sizeof(VkuFrameset) / sizeof(VkuFrameset::count));
std::vector<VlFrameset> input_values{ std::vector<VkuFrameset> input_values{
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
@ -282,16 +282,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VlFrameset> values(input_values.size()); std::vector<VkuFrameset> values(input_values.size());
uint32_t value_count = 2 * frameset_size; uint32_t value_count = 2 * frameset_size;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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);
@ -302,23 +302,23 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(6, value_count); EXPECT_EQ(6, value_count);
value_count = 0; value_count = 0;
result_complete = vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr); result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<const char*> string_values(input_values.size()); std::vector<const char*> string_values(input_values.size());
value_count = 2; value_count = 2;
result_complete = result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, &string_values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, &string_values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_STREQ("76-100-10", string_values[0]); EXPECT_STREQ("76-100-10", string_values[0]);
EXPECT_STREQ("1-100-1", string_values[1]); EXPECT_STREQ("1-100-1", string_values[1]);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"}; std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
@ -327,20 +327,20 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) {
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<const char*> values(input_values.size()); std::vector<const char*> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }

256
tests/layer/test_setting_cpp.cpp
View file

@ -12,7 +12,7 @@
#include <iterator> #include <iterator>
#include <vector> #include <vector>
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Bool) {
const VkBool32 value_data{VK_TRUE}; const VkBool32 value_data{VK_TRUE};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &value_data};
@ -20,20 +20,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
bool pValues = true; bool pValues = true;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(true, pValues); EXPECT_EQ(true, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Bool) {
const VkBool32 values_data[] = {VK_TRUE, VK_FALSE}; const VkBool32 values_data[] = {VK_TRUE, VK_FALSE};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -45,22 +45,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<bool> values; std::vector<bool> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(true, values[0]); EXPECT_EQ(true, values[0]);
EXPECT_EQ(false, values[1]); EXPECT_EQ(false, values[1]);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Int32) {
const std::int32_t value_data{76}; const std::int32_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &value_data};
@ -68,20 +68,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::int32_t pValues; std::int32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, pValues); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Int32) {
const std::int32_t values_data[] = {76, 82}; const std::int32_t values_data[] = {76, 82};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -93,22 +93,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::int32_t> values; std::vector<std::int32_t> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint32) {
const std::uint32_t value_data{76}; const std::uint32_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 1, &value_data};
@ -116,20 +116,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::uint32_t pValues; std::uint32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, pValues); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint32) {
const std::uint32_t values_data[] = {76, 82}; const std::uint32_t values_data[] = {76, 82};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -141,22 +141,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::uint32_t> values; std::vector<std::uint32_t> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Int64) {
const std::int64_t value_data{76}; const std::int64_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, 1, &value_data};
@ -164,20 +164,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::int64_t pValues; std::int64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, pValues); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Int64) {
const std::int64_t values_data[] = {76, 82}; const std::int64_t values_data[] = {76, 82};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -189,22 +189,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::int64_t> values; std::vector<std::int64_t> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint64) {
const std::uint64_t value_data{76}; const std::uint64_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, 1, &value_data};
@ -212,20 +212,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::uint64_t pValues; std::uint64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, pValues); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint64) {
const std::uint64_t values_data[] = {76, 82}; const std::uint64_t values_data[] = {76, 82};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -237,22 +237,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::uint64_t> values; std::vector<std::uint64_t> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0]); EXPECT_EQ(76, values[0]);
EXPECT_EQ(82, values[1]); EXPECT_EQ(82, values[1]);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Float) {
const float value_data{-82.5f}; const float value_data{-82.5f};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, 1, &value_data};
@ -260,20 +260,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
float pValues; float pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(pValues - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(pValues - -82.5f) <= 0.0001f);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Float) {
const float values_data[] = {76.1f, -82.5f}; const float values_data[] = {76.1f, -82.5f};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -285,22 +285,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<float> values; std::vector<float> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
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, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Double) {
const double value_data{-82.5}; const double value_data{-82.5};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, 1, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, 1, &value_data};
@ -308,20 +308,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
double pValues; double pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(pValues - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(pValues - -82.5) <= 0.0001);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Double) {
const double values_data[] = {76.1, -82.5}; const double values_data[] = {76.1, -82.5};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -333,22 +333,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<double> values; std::vector<double> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
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, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_String) {
const char* value_data[] = {"VALUE_A"}; const char* value_data[] = {"VALUE_A"};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, value_data};
@ -356,17 +356,17 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string pValues; std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A", pValues.c_str()); EXPECT_STREQ("VALUE_A", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Strings) {
const char* values_data[] = {"VALUE_A", "VALUE_B"}; const char* values_data[] = {"VALUE_A", "VALUE_B"};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -378,17 +378,17 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string pValues; std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A,VALUE_B", pValues.c_str()); EXPECT_STREQ("VALUE_A,VALUE_B", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_String) {
const char* values_data[] = {"VALUE_A", "VALUE_B"}; const char* values_data[] = {"VALUE_A", "VALUE_B"};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -400,48 +400,48 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<std::string> values; std::vector<std::string> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_STREQ("VALUE_A", values[0].c_str()); EXPECT_STREQ("VALUE_A", values[0].c_str());
EXPECT_STREQ("VALUE_B", values[1].c_str()); EXPECT_STREQ("VALUE_B", values[1].c_str());
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Frameset) {
const VlFrameset value_data{76, 100, 10}; const VkuFrameset value_data{76, 100, 10};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 3, &value_data}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 3, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
VlFrameset pValues; VkuFrameset pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues); vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, pValues.first); EXPECT_EQ(76, pValues.first);
EXPECT_EQ(100, pValues.count); EXPECT_EQ(100, pValues.count);
EXPECT_EQ(10, pValues.step); EXPECT_EQ(10, pValues.step);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Frameset) {
const VlFrameset values_data[] = { const VkuFrameset values_data[] = {
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data) * (sizeof(VlFrameset) / sizeof(VlFrameset::count))); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data) * (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, value_count, values_data} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, value_count, values_data}
@ -451,13 +451,13 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VlFrameset> values; std::vector<VkuFrameset> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
EXPECT_EQ(100, values[0].count); EXPECT_EQ(100, values[0].count);
@ -467,10 +467,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(1, values[1].step); EXPECT_EQ(1, values[1].step);
EXPECT_EQ(2, values.size()); EXPECT_EQ(2, values.size());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_VkuCustomSTypeInfo) {
const char* values_data[] = {"0x76", "0X82", "76", "82"}; const char* values_data[] = {"0x76", "0X82", "76", "82"};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
@ -482,22 +482,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) {
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{ const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VlCustomSTypeInfo> values; std::vector<VkuCustomSTypeInfo> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(0x76, values[0].first); EXPECT_EQ(0x76, values[0].first);
EXPECT_EQ(0x82, values[0].second); EXPECT_EQ(0x82, values[0].second);
EXPECT_EQ(76, values[1].first); EXPECT_EQ(76, values[1].first);
EXPECT_EQ(82, values[1].second); EXPECT_EQ(82, values[1].second);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetUnknownSettings) { TEST(test_layer_setting_cpp, vkuGetUnknownSettings) {
std::vector<VkLayerSettingEXT> settings; std::vector<VkLayerSettingEXT> settings;
VkBool32 value_bool = VK_TRUE; VkBool32 value_bool = VK_TRUE;
@ -563,13 +563,13 @@ TEST(test_layer_setting_cpp, vlGetUnknownSettings) {
setting_double_value.count = 1; setting_double_value.count = 1;
settings.push_back(setting_double_value); settings.push_back(setting_double_value);
VlFrameset value_frameset{76, 100, 10}; VkuFrameset value_frameset{76, 100, 10};
VkLayerSettingEXT setting_frameset_value{}; VkLayerSettingEXT setting_frameset_value{};
setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_frameset_value.pSettingName = "frameset_value"; setting_frameset_value.pSettingName = "frameset_value";
setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT; setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
setting_frameset_value.pValues = &value_frameset; setting_frameset_value.pValues = &value_frameset;
setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count); setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
settings.push_back(setting_frameset_value); settings.push_back(setting_frameset_value);
VkLayerSettingsCreateInfoEXT layer_settings_create_info; VkLayerSettingsCreateInfoEXT layer_settings_create_info;
@ -582,7 +582,7 @@ TEST(test_layer_setting_cpp, vlGetUnknownSettings) {
const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names)); const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names));
std::vector<const char*> unknown_settings; std::vector<const char*> unknown_settings;
vlGetUnknownSettings(&layer_settings_create_info, setting_name_count, setting_names, unknown_settings); vkuGetUnknownSettings(&layer_settings_create_info, setting_name_count, setting_names, unknown_settings);
EXPECT_EQ(2, unknown_settings.size()); EXPECT_EQ(2, unknown_settings.size());
EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("bool_value", unknown_settings[0]);

196
tests/layer/test_setting_env.cpp
View file

@ -24,116 +24,116 @@ static void SetEnv(const char* value) {
TEST(test_layer_setting_env, EnvVar_TrimNone) { TEST(test_layer_setting_env, EnvVar_TrimNone) {
SetEnv("VK_LUNARG_TEST_MY_SETTING_A=true,false"); SetEnv("VK_LUNARG_TEST_MY_SETTING_A=true,false");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_a")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_a"));
uint32_t value_count_a = 0; uint32_t value_count_a = 0;
VkResult result_count_a = VkResult result_count_a =
vlGetLayerSettingValues(layerSettingSet, "my_setting_a", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count_a); EXPECT_EQ(VK_SUCCESS, result_count_a);
EXPECT_EQ(2, value_count_a); EXPECT_EQ(2, value_count_a);
std::vector<VkBool32> values_a(static_cast<std::size_t>(value_count_a)); std::vector<VkBool32> values_a(static_cast<std::size_t>(value_count_a));
VkResult result_complete_a = VkResult result_complete_a =
vlGetLayerSettingValues(layerSettingSet, "my_setting_a", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_a, &values_a[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, &values_a[0]);
EXPECT_EQ(VK_SUCCESS, result_complete_a); EXPECT_EQ(VK_SUCCESS, result_complete_a);
EXPECT_EQ(VK_TRUE, values_a[0]); EXPECT_EQ(VK_TRUE, values_a[0]);
EXPECT_EQ(VK_FALSE, values_a[1]); EXPECT_EQ(VK_FALSE, values_a[1]);
EXPECT_EQ(2, value_count_a); EXPECT_EQ(2, value_count_a);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, EnvVar_TrimVendor) { TEST(test_layer_setting_env, EnvVar_TrimVendor) {
SetEnv("VK_TEST_MY_SETTING_B=true,false"); SetEnv("VK_TEST_MY_SETTING_B=true,false");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_b")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_b"));
uint32_t value_count_b = 0; uint32_t value_count_b = 0;
VkResult result_count_b = VkResult result_count_b =
vlGetLayerSettingValues(layerSettingSet, "my_setting_b", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count_b); EXPECT_EQ(VK_SUCCESS, result_count_b);
EXPECT_EQ(2, value_count_b); EXPECT_EQ(2, value_count_b);
std::vector<VkBool32> values_b(static_cast<std::size_t>(value_count_b)); std::vector<VkBool32> values_b(static_cast<std::size_t>(value_count_b));
VkResult result_complete_b = VkResult result_complete_b =
vlGetLayerSettingValues(layerSettingSet, "my_setting_b", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_b, &values_b[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, &values_b[0]);
EXPECT_EQ(VK_SUCCESS, result_complete_b); EXPECT_EQ(VK_SUCCESS, result_complete_b);
EXPECT_EQ(VK_TRUE, values_b[0]); EXPECT_EQ(VK_TRUE, values_b[0]);
EXPECT_EQ(VK_FALSE, values_b[1]); EXPECT_EQ(VK_FALSE, values_b[1]);
EXPECT_EQ(2, value_count_b); EXPECT_EQ(2, value_count_b);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, EnvVar_TrimNamespace) { TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
SetEnv("VK_MY_SETTING_C=true,false"); SetEnv("VK_MY_SETTING_C=true,false");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_c")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_c"));
uint32_t value_count_c = 0; uint32_t value_count_c = 0;
VkResult result_count_c = VkResult result_count_c =
vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count_c); EXPECT_EQ(VK_SUCCESS, result_count_c);
EXPECT_EQ(2, value_count_c); EXPECT_EQ(2, value_count_c);
std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c)); std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
VkResult result_complete_c = VkResult result_complete_c =
vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
EXPECT_EQ(VK_SUCCESS, result_complete_c); EXPECT_EQ(VK_SUCCESS, result_complete_c);
EXPECT_EQ(VK_TRUE, values_c[0]); EXPECT_EQ(VK_TRUE, values_c[0]);
EXPECT_EQ(VK_FALSE, values_c[1]); EXPECT_EQ(VK_FALSE, values_c[1]);
EXPECT_EQ(2, value_count_c); EXPECT_EQ(2, value_count_c);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) { TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
SetEnv("VK_POUET_MY_SETTING_C=true,false"); SetEnv("VK_POUET_MY_SETTING_C=true,false");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
vlSetLayerSettingCompatibilityNamespace(layerSettingSet, "POUET"); vkuSetLayerSettingCompatibilityNamespace(layerSettingSet, "POUET");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_c")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_c"));
uint32_t value_count_c = 0; uint32_t value_count_c = 0;
VkResult result_count_c = VkResult result_count_c =
vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count_c); EXPECT_EQ(VK_SUCCESS, result_count_c);
EXPECT_EQ(2, value_count_c); EXPECT_EQ(2, value_count_c);
std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c)); std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
VkResult result_complete_c = VkResult result_complete_c =
vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
EXPECT_EQ(VK_SUCCESS, result_complete_c); EXPECT_EQ(VK_SUCCESS, result_complete_c);
EXPECT_EQ(VK_TRUE, values_c[0]); EXPECT_EQ(VK_TRUE, values_c[0]);
EXPECT_EQ(VK_FALSE, values_c[1]); EXPECT_EQ(VK_FALSE, values_c[1]);
EXPECT_EQ(2, value_count_c); EXPECT_EQ(2, value_count_c);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=true,false"); SetEnv("VK_LUNARG_TEST_MY_SETTING=true,false");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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);
@ -141,7 +141,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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]);
@ -149,26 +149,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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);
@ -176,7 +176,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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]);
@ -184,26 +184,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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);
@ -211,7 +211,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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]);
@ -219,26 +219,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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);
@ -246,7 +246,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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]);
@ -254,26 +254,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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);
@ -281,7 +281,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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]);
@ -289,26 +289,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1f,-82.5f"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1f,-82.5f");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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);
@ -316,33 +316,33 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1,-82.5"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1,-82.5");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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);
@ -350,41 +350,41 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=76-100-10,1-100-1"); SetEnv("VK_LUNARG_TEST_MY_SETTING=76-100-10,1-100-1");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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<VlFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -393,7 +393,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -403,20 +403,20 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_env, vlGetLayerSettingValues_String) { TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
SetEnv("VK_LUNARG_TEST_MY_SETTING=VALUE_A,VALUE_B"); SetEnv("VK_LUNARG_TEST_MY_SETTING=VALUE_A,VALUE_B");
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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);
@ -424,7 +424,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_String) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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]);
@ -432,11 +432,11 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_String) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }

148
tests/layer/test_setting_file.cpp
View file

@ -11,19 +11,19 @@
#include "vulkan/layer/vk_layer_settings.h" #include "vulkan/layer/vk_layer_settings.h"
#include <vector> #include <vector>
void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue); void test_helper_SetLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue);
TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "true,false"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "true,false");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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);
@ -31,7 +31,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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]);
@ -39,26 +39,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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);
@ -66,7 +66,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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]);
@ -74,26 +74,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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);
@ -101,7 +101,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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]);
@ -109,26 +109,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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);
@ -136,7 +136,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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]);
@ -144,26 +144,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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);
@ -171,7 +171,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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]);
@ -179,26 +179,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1f,-82.5f"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1f,-82.5f");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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);
@ -206,33 +206,33 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1,-82.5"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1,-82.5");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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);
@ -240,41 +240,41 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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 = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "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(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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<VlFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -283,7 +283,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &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);
@ -293,20 +293,20 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_file, vlGetLayerSettingValues_String) { TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet); vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "VALUE_A,VALUE_B"); test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "VALUE_A,VALUE_B");
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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);
@ -314,7 +314,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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]);
@ -322,11 +322,11 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &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); vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
} }

44
tests/layer/test_setting_util.cpp
View file

@ -23,7 +23,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_first) {
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = &layerSettingsCreateInfo; instanceCreateInfo.pNext = &layerSettingsCreateInfo;
EXPECT_EQ(&layerSettingsCreateInfo, vlFindLayerSettingsCreateInfo(&instanceCreateInfo)); EXPECT_EQ(&layerSettingsCreateInfo, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
} }
TEST(test_layer_settings_util, FindSettingsInChain_found_last) { TEST(test_layer_settings_util, FindSettingsInChain_found_last) {
@ -38,7 +38,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_last) {
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = &debugReportCallbackCreateInfo; instanceCreateInfo.pNext = &debugReportCallbackCreateInfo;
EXPECT_EQ(&layerSettingsCreateInfo, vlFindLayerSettingsCreateInfo(&instanceCreateInfo)); EXPECT_EQ(&layerSettingsCreateInfo, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
} }
TEST(test_layer_settings_util, FindSettingsInChain_found_not) { TEST(test_layer_settings_util, FindSettingsInChain_found_not) {
@ -49,7 +49,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_not) {
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = &debugReportCallbackCreateInfo; instanceCreateInfo.pNext = &debugReportCallbackCreateInfo;
EXPECT_EQ(nullptr, vlFindLayerSettingsCreateInfo(&instanceCreateInfo)); EXPECT_EQ(nullptr, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
} }
TEST(test_layer_settings_util, FindDelimiter) { TEST(test_layer_settings_util, FindDelimiter) {
@ -405,7 +405,7 @@ TEST(test_layer_settings_util, is_framesets) {
TEST(test_layer_settings_util, to_framesets) { TEST(test_layer_settings_util, to_framesets) {
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("0"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("0");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -414,7 +414,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("76"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("76");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(76, framesets[0].first); EXPECT_EQ(76, framesets[0].first);
@ -423,7 +423,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -432,7 +432,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2,6,7"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6,7");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -449,7 +449,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2,6-7"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6-7");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -462,7 +462,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-2,60,70"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-2,60,70");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -479,7 +479,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("10-20,60,70"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("10-20,60,70");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(10, framesets[0].first); EXPECT_EQ(10, framesets[0].first);
@ -496,7 +496,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -505,7 +505,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,0"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,0");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -518,7 +518,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -531,7 +531,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8,10-20-5"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -544,7 +544,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -557,7 +557,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VlFrameset> framesets = vl::ToFrameSets("1,2,3,4"); std::vector<VkuFrameset> framesets = vl::ToFrameSets("1,2,3,4");
EXPECT_EQ(4, framesets.size()); EXPECT_EQ(4, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -578,7 +578,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
} }
TEST(test_layer_settings_util, vlGetUnknownSettings) { TEST(test_layer_settings_util, vkuGetUnknownSettings) {
std::vector<VkLayerSettingEXT> settings; std::vector<VkLayerSettingEXT> settings;
VkBool32 value_bool = VK_TRUE; VkBool32 value_bool = VK_TRUE;
@ -644,13 +644,13 @@ TEST(test_layer_settings_util, vlGetUnknownSettings) {
setting_double_value.count = 1; setting_double_value.count = 1;
settings.push_back(setting_double_value); settings.push_back(setting_double_value);
VlFrameset value_frameset{76, 100, 10}; VkuFrameset value_frameset{76, 100, 10};
VkLayerSettingEXT setting_frameset_value{}; VkLayerSettingEXT setting_frameset_value{};
setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_frameset_value.pSettingName = "frameset_value"; setting_frameset_value.pSettingName = "frameset_value";
setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT; setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
setting_frameset_value.pValues = &value_frameset; setting_frameset_value.pValues = &value_frameset;
setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count); setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
settings.push_back(setting_frameset_value); settings.push_back(setting_frameset_value);
VkLayerSettingsCreateInfoEXT create_info; VkLayerSettingsCreateInfoEXT create_info;
@ -665,18 +665,18 @@ TEST(test_layer_settings_util, vlGetUnknownSettings) {
const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names)); const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names));
uint32_t unknown_settings_count = 0; uint32_t unknown_settings_count = 0;
vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr); vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr);
EXPECT_EQ(2, unknown_settings_count); EXPECT_EQ(2, unknown_settings_count);
std::vector<const char*> unknown_settings(unknown_settings_count); std::vector<const char*> unknown_settings(unknown_settings_count);
unknown_settings_count = 1; unknown_settings_count = 1;
vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
EXPECT_EQ(1, unknown_settings_count); EXPECT_EQ(1, unknown_settings_count);
EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("bool_value", unknown_settings[0]);
unknown_settings_count = 2; unknown_settings_count = 2;
vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("bool_value", unknown_settings[0]);
EXPECT_STREQ("frameset_value", unknown_settings[1]); EXPECT_STREQ("frameset_value", unknown_settings[1]);