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

layer: Improve API consistency

Browse source
This commit is contained in:
Christophe 2023-08-08 17:09:13 +02:00 • committed by Christophe
parent 430013c64e
commit 87b77bc639
14 changed files with 274 additions and 314 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -62,10 +62,10 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
const char *pSettingName, std::vector<std::string> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
const char *pSettingName, VkFrameset &settingValue);
const char *pSettingName, VkFramesetEXT &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
const char *pSettingName, std::vector<VkFrameset> &settingValues);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName,
std::vector<VkFramesetEXT> &settingValues);
// Required by vk_safe_struct
typedef std::pair<uint32_t, uint32_t> VlCustomSTypeInfo;

65
include/vulkan/layer/vk_layer_settings_ext.h
View file

@ -37,37 +37,19 @@ extern "C" {
// Mark Lobodzinski
//
// Description
// This extension provides the VkLayerSettingsEXT struct that can be included in the pNext chain of the
// VkInstanceCreateInfo structure passed as the pCreateInfo parameter of vkCreateInstance
// The structure contains an array of VkLayerSettingValueEXT structures that define layer specific settings
// The extension also provides the vkEnumerateInstanceLayerSettingsEXT and vkEnumerateInstanceLayerSettingOptionEXT
// commands, useful for enumerating all layer settings and their possible values, respectively.
// This extension provides a mechanism for configuring programmatically through
// the Vulkan API the behavior of layers.
//
// This extension provides the [VkLayerSettingsCreateInfoEXT] struct that can be
// included in the [pNext] chain of the [VkInstanceCreateInfo]
// structure passed as the [pCreateInfo] parameter of [vkCreateInstance].
//
// The structure contains an array of [VkLayerSettingEXT] structure
// values that configure specific features of layers.
//
// Note
// The VK_EXT_layer_settings extension subsumes all the functionality provided in the [VK_EXT_validation_flags] extension
// The [VK_EXT_layer_settings] extension subsumes all the functionality provided in the [VK_EXT_validation_flags] extension
// and the [VK_EXT_validation_features] extension.
//
// New Commands
// vkEnumerateInstanceLayerSettingsEXT
// vkEnumerateInstanceLayerSettingOptionEXT
//
// New Structures
// array_int32
// array_int64
// array_float
// array_bool
// array_char
// VkLayerSettingValueEXT
// VkLayerSettingDescriptionEXT
// VkLayerSettingOptionEXT
// Extending VkInstanceCreateInfo :
// VkLayerSettingsEXT
//
// New Unions
// VkLayerSettingValueDataEXT
//
// New Enums
// VkLayerSettingValueTypeEXT
#define VK_EXT_layer_settings 1
#define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 1
@ -82,40 +64,29 @@ extern "C" {
#define VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT ((VkStructureType)(VK_STRUCTURE_TYPE_MAX_ENUM - 43))
typedef enum VkLayerSettingTypeEXT {
VK_LAYER_SETTING_TYPE_BOOL_EXT = 0,
VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0,
VK_LAYER_SETTING_TYPE_INT32_EXT,
VK_LAYER_SETTING_TYPE_INT64_EXT,
VK_LAYER_SETTING_TYPE_UINT32_EXT,
VK_LAYER_SETTING_TYPE_UINT64_EXT,
VK_LAYER_SETTING_TYPE_FLOAT_EXT,
VK_LAYER_SETTING_TYPE_DOUBLE_EXT,
VK_LAYER_SETTING_TYPE_FRAMESET_EXT,
VK_LAYER_SETTING_TYPE_STRING_EXT
VK_LAYER_SETTING_TYPE_FLOAT32_EXT,
VK_LAYER_SETTING_TYPE_FLOAT64_EXT,
VK_LAYER_SETTING_TYPE_STRING_EXT,
VK_LAYER_SETTING_TYPE_FRAMESET_EXT
} VkLayerSettingTypeEXT;
typedef struct VkFrameset {
typedef struct VkFramesetEXT {
uint32_t first;
uint32_t count;
uint32_t step;
} VkFrameset;
} VkFramesetEXT;
typedef struct VkLayerSettingEXT {
const char *pLayerName;
const char *pSettingName;
VkLayerSettingTypeEXT type;
uint32_t count;
union {
const void *value;
const VkBool32 *asBool32;
const int32_t *asInt32;
const int64_t *asInt64;
const uint32_t *asUint32;
const uint64_t *asUint64;
const float *asFloat;
const double *asDouble;
const VkFrameset *asFrameset;
const char **asString;
};
const void *pValues;
} VkLayerSettingEXT;
typedef struct VkLayerSettingsCreateInfoEXT {

14
src/layer/layer_settings_manager.cpp
View file

@ -148,11 +148,11 @@ std::string LayerSettings::FindSettingsFile() {
LSTATUS err = RegOpenKeyEx(hives[hive_index], "Software\\Khronos\\Vulkan\\Settings", 0, KEY_READ, &key);
if (err == ERROR_SUCCESS) {
char name[2048];
DWORD i = 0, name_size, type, value, value_size;
DWORD i = 0, name_size, type, pValues, value_size;
while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type,
reinterpret_cast<LPBYTE>(&value), &(value_size = sizeof(value)))) {
reinterpret_cast<LPBYTE>(&pValues), &(value_size = sizeof(pValues)))) {
// Check if the registry entry is a dword with a value of zero
if (type != REG_DWORD || value != 0) {
if (type != REG_DWORD || pValues != 0) {
continue;
}
@ -315,16 +315,16 @@ std::string LayerSettings::GetFileSetting(const char *pSettingName) {
}
}
void LayerSettings::SetFileSetting(const char *pSettingName, const std::string &value) {
void LayerSettings::SetFileSetting(const char *pSettingName, const std::string &pValues) {
assert(pSettingName != nullptr);
this->setting_file_values.insert({pSettingName, value});
this->setting_file_values.insert({pSettingName, pValues});
}
const LayerSetting *LayerSettings::GetAPISetting(const char *pSettingName) {
const VkLayerSettingEXT *LayerSettings::GetAPISetting(const char *pSettingName) {
assert(pSettingName != nullptr);
return reinterpret_cast<const LayerSetting *>(this->FindLayerSettingValue(pSettingName));
return reinterpret_cast<const VkLayerSettingEXT *>(this->FindLayerSettingValue(pSettingName));
}
} // namespace vl

22
src/layer/layer_settings_manager.hpp
View file

@ -15,24 +15,6 @@
#include <map>
namespace vl {
struct LayerSetting {
const char *pLayerName;
const char *pSettingName;
VkLayerSettingTypeEXT type;
uint32_t count;
union {
const VkBool32 *asBool32;
const int32_t *asInt32;
const int64_t *asInt64;
const uint32_t *asUint32;
const uint64_t *asUint64;
const float *asFloat;
const double *asDouble;
const VkFrameset *asFrameset;
const char **asString;
};
};
class LayerSettings {
public:
LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
@ -49,9 +31,9 @@ namespace vl {
std::string GetFileSetting(const char *pSettingName);
void SetFileSetting(const char *pSettingName, const std::string& value);
void SetFileSetting(const char *pSettingName, const std::string& pValues);
const LayerSetting *GetAPISetting(const char *pSettingName);
const VkLayerSettingEXT *GetAPISetting(const char *pSettingName);
void Log(const char *pSettingName, const char *pMessage);

12
src/layer/layer_settings_util.cpp
View file

@ -16,10 +16,10 @@
namespace vl {
std::vector<std::string> Split(const std::string &value, char delimiter) {
std::vector<std::string> Split(const std::string &pValues, char delimiter) {
std::vector<std::string> result;
std::string parse = value;
std::string parse = pValues;
std::size_t start = 0;
std::size_t end = parse.find(delimiter);
@ -198,10 +198,10 @@ int64_t ToInt64(const std::string &token) {
return int_id;
}
VkFrameset ToFrameSet(const std::string &s) {
VkFramesetEXT ToFrameSet(const std::string &s) {
assert(IsFrameSets(s));
VkFrameset frameset{0, 1, 1};
VkFramesetEXT frameset{0, 1, 1};
const std::vector<std::string> &frameset_split = vl::Split(s, '-');
if (frameset_split.size() >= 1) {
@ -217,10 +217,10 @@ VkFrameset ToFrameSet(const std::string &s) {
return frameset;
}
std::vector<VkFrameset> ToFrameSets(const std::string &s) {
std::vector<VkFramesetEXT> ToFrameSets(const std::string &s) {
std::vector<std::string> tokens = Split(s, FindDelimiter(s));
std::vector<VkFrameset> results;
std::vector<VkFramesetEXT> results;
results.resize(tokens.size());
for (std::size_t i = 0, n = tokens.size(); i < n; ++i) {
results[i] = ToFrameSet(tokens[i]);

6
src/layer/layer_settings_util.hpp
View file

@ -20,7 +20,7 @@ namespace vl {
const void *next);
std::vector<std::string> Split(
const std::string &value, char delimiter);
const std::string &pValues, char delimiter);
enum TrimMode {
TRIM_NONE,
@ -62,9 +62,9 @@ namespace vl {
bool IsFrameSets(const std::string &s);
VkFrameset ToFrameSet(const std::string &s);
VkFramesetEXT ToFrameSet(const std::string &s);
std::vector<VkFrameset> ToFrameSets(const std::string &s);
std::vector<VkFramesetEXT> ToFrameSets(const std::string &s);
bool IsInteger(const std::string &s);

65
src/layer/vk_layer_settings.cpp
View file

@ -87,7 +87,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
const std::string &file_setting_list = layer_setting_set->GetFileSetting(pSettingName);
// Third: search from VK_EXT_layer_settings usage
const vl::LayerSetting *api_setting = layer_setting_set->GetAPISetting(pSettingName);
const VkLayerSettingEXT *api_setting = layer_setting_set->GetAPISetting(pSettingName);
// Environment variables overrides the values set by vk_layer_settings
const std::string setting_list = env_setting_list.empty() ? file_setting_list : env_setting_list;
@ -107,7 +107,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
layer_setting_set->Log(pSettingName, message.c_str());
return VK_ERROR_UNKNOWN;
}
case VK_LAYER_SETTING_TYPE_BOOL_EXT: {
case VK_LAYER_SETTING_TYPE_BOOL32_EXT: {
std::vector<VkBool32> values;
VkResult result = VK_SUCCESS;
@ -141,7 +141,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asBool32, api_setting->asBool32 + size);
const VkBool32 *data = static_cast<const VkBool32 *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -185,7 +186,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asInt32, api_setting->asInt32 + size);
const int32_t *data = static_cast<const int32_t *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -229,7 +231,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asInt64, api_setting->asInt64 + size);
const int64_t *data = static_cast<const int64_t *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -273,7 +276,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asUint32, api_setting->asUint32 + size);
const uint32_t *data = static_cast<const uint32_t *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -317,7 +321,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asUint64, api_setting->asUint64 + size);
const uint64_t *data = static_cast<const uint64_t *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -329,7 +334,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result;
}
case VK_LAYER_SETTING_TYPE_FLOAT_EXT: {
case VK_LAYER_SETTING_TYPE_FLOAT32_EXT: {
std::vector<float> values;
VkResult result = VK_SUCCESS;
@ -361,7 +366,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asFloat, api_setting->asFloat + size);
const float *data = static_cast<const float *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -373,7 +379,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result;
}
case VK_LAYER_SETTING_TYPE_DOUBLE_EXT: {
case VK_LAYER_SETTING_TYPE_FLOAT64_EXT: {
std::vector<double> values;
VkResult result = VK_SUCCESS;
@ -405,7 +411,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asDouble, api_setting->asDouble + size);
const double *data = static_cast<const double *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
@ -418,7 +425,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result;
}
case VK_LAYER_SETTING_TYPE_FRAMESET_EXT: {
std::vector<VkFrameset> values;
std::vector<VkFramesetEXT> values;
VkResult result = VK_SUCCESS;
if (!settings.empty()) { // From env variable or setting file
@ -449,14 +456,15 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE;
}
const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asFrameset, api_setting->asFrameset + size);
const VkFramesetEXT *data = static_cast<const VkFramesetEXT *>(api_setting->pValues);
values.assign(data, data + size);
} else {
*pValueCount = api_setting->count;
}
}
if (copy_values) {
std::copy(values.begin(), values.end(), reinterpret_cast<VkFrameset *>(pValues));
std::copy(values.begin(), values.end(), reinterpret_cast<VkFramesetEXT *>(pValues));
}
return result;
@ -487,50 +495,49 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
switch (api_setting->type) {
case VK_LAYER_SETTING_TYPE_STRING_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = api_setting->asString[i];
settings_cache[i] = reinterpret_cast<const char * const *>(api_setting->pValues)[i];
}
break;
case VK_LAYER_SETTING_TYPE_BOOL_EXT:
case VK_LAYER_SETTING_TYPE_BOOL32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = api_setting->asBool32[i] == VK_TRUE ? "true" : "false";
settings_cache[i] =
static_cast<const VkBool32 *>(api_setting->pValues)[i] == VK_TRUE ? "true" : "false";
}
break;
case VK_LAYER_SETTING_TYPE_INT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%d", api_setting->asInt32[i]);
settings_cache[i] = vl::Format("%d", static_cast<const int32_t *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_INT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%lld", api_setting->asInt64[i]);
settings_cache[i] = vl::Format("%lld", static_cast<const int64_t *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_UINT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%u", api_setting->asUint32[i]);
settings_cache[i] = vl::Format("%u", static_cast<const uint32_t *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_UINT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%llu", api_setting->asUint64[i]);
settings_cache[i] = vl::Format("%llu", static_cast<const uint64_t *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_FLOAT_EXT:
case VK_LAYER_SETTING_TYPE_FLOAT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%f", api_setting->asFloat[i]);
settings_cache[i] = vl::Format("%f", static_cast<const float *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_DOUBLE_EXT:
case VK_LAYER_SETTING_TYPE_FLOAT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%f", api_setting->asDouble[i]);
settings_cache[i] = vl::Format("%f", static_cast<const double *>(api_setting->pValues)[i]);
}
break;
case VK_LAYER_SETTING_TYPE_FRAMESET_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%d-%d-%d",
api_setting->asFrameset[i].first,
api_setting->asFrameset[i].count,
api_setting->asFrameset[i].step);
const VkFramesetEXT* asFramesets = static_cast<const VkFramesetEXT*>(api_setting->pValues);
settings_cache[i] = vl::Format("%d-%d-%d", asFramesets[i].first, asFramesets[i].count, asFramesets[i].step);
}
break;
default:

26
src/layer/vk_layer_settings_helper.cpp
View file

@ -23,17 +23,17 @@ static std::string Merge(const std::vector<std::string> &strings) {
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
uint32_t value_count = 1;
VkBool32 value;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &value);
settingValue = value == VK_TRUE;
VkBool32 pValues;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &pValues);
settingValue = pValues == VK_TRUE;
}
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
if (value_count > 0) {
std::vector<VkBool32> values(value_count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
for (std::size_t i = 0, n = values.size(); i < n; ++i) {
settingValues.push_back(values[i] == VK_TRUE);
}
@ -98,29 +98,29 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSet
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValue);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &settingValue);
}
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValues[0]);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &settingValues[0]);
}
}
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValue);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &settingValue);
}
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValues[0]);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &settingValues[0]);
}
}
@ -140,12 +140,12 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSet
}
}
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VkFrameset& settingValue) {
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VkFramesetEXT& settingValue) {
uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &settingValue);
}
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char* pSettingName, std::vector<VkFrameset>& settingValues) {
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkFramesetEXT> &settingValues) {
uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
if (value_count > 0) {

68
tests/layer/test_setting_api.cpp
View file

@ -22,14 +22,14 @@ TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) {
}
TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
std::int32_t value = 76;
std::int32_t pValues = 76;
VkLayerSettingEXT my_setting;
my_setting.pLayerName = "VK_LAYER_LUNARG_test";
my_setting.pSettingName = "my_setting";
my_setting.type = VK_LAYER_SETTING_TYPE_INT32_EXT;
my_setting.count = 1;
my_setting.asInt32 = &value;
my_setting.pValues = &pValues;
std::vector<VkLayerSettingEXT> settings;
settings.push_back(my_setting);
@ -53,8 +53,8 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_bool_value{};
setting_bool_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_bool_value.pSettingName = "bool_value";
setting_bool_value.type = VK_LAYER_SETTING_TYPE_BOOL_EXT;
setting_bool_value.asBool32 = &value_bool;
setting_bool_value.type = VK_LAYER_SETTING_TYPE_BOOL32_EXT;
setting_bool_value.pValues = &value_bool;
setting_bool_value.count = 1;
settings.push_back(setting_bool_value);
@ -63,7 +63,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_int32_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_int32_value.pSettingName = "int32_value";
setting_int32_value.type = VK_LAYER_SETTING_TYPE_INT32_EXT;
setting_int32_value.asInt32 = &value_int32;
setting_int32_value.pValues = &value_int32;
setting_int32_value.count = 1;
settings.push_back(setting_int32_value);
@ -72,7 +72,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_int64_value.pSettingName = "int64_value";
setting_int64_value.type = VK_LAYER_SETTING_TYPE_INT64_EXT;
setting_int64_value.asInt64 = &value_int64;
setting_int64_value.pValues = &value_int64;
setting_int64_value.count = 1;
settings.push_back(setting_int64_value);
@ -81,7 +81,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_uint32_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_uint32_value.pSettingName = "uint32_value";
setting_uint32_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
setting_uint32_value.asUint32 = &value_uint32;
setting_uint32_value.pValues = &value_uint32;
setting_uint32_value.count = 1;
settings.push_back(setting_uint32_value);
@ -90,7 +90,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_uint64_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_uint64_value.pSettingName = "uint64_value";
setting_uint64_value.type = VK_LAYER_SETTING_TYPE_UINT64_EXT;
setting_uint64_value.asUint64 = &value_uint64;
setting_uint64_value.pValues = &value_uint64;
setting_uint64_value.count = 1;
settings.push_back(setting_uint64_value);
@ -98,8 +98,8 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_float_value{};
setting_float_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_float_value.pSettingName = "float_value";
setting_float_value.type = VK_LAYER_SETTING_TYPE_FLOAT_EXT;
setting_float_value.asFloat = &value_float;
setting_float_value.type = VK_LAYER_SETTING_TYPE_FLOAT32_EXT;
setting_float_value.pValues = &value_float;
setting_float_value.count = 1;
settings.push_back(setting_float_value);
@ -107,17 +107,17 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_double_value{};
setting_double_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_double_value.pSettingName = "double_value";
setting_double_value.type = VK_LAYER_SETTING_TYPE_DOUBLE_EXT;
setting_double_value.asDouble = &value_double;
setting_double_value.type = VK_LAYER_SETTING_TYPE_FLOAT64_EXT;
setting_double_value.pValues = &value_double;
setting_double_value.count = 1;
settings.push_back(setting_double_value);
VkFrameset value_frameset{76, 100, 10};
VkFramesetEXT value_frameset{76, 100, 10};
VkLayerSettingEXT setting_frameset_value{};
setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_frameset_value.pSettingName = "frameset_value";
setting_frameset_value.type = VK_LAYER_SETTING_TYPE_FRAMESET_EXT;
setting_frameset_value.asFrameset = &value_frameset;
setting_frameset_value.pValues = &value_frameset;
setting_frameset_value.count = 1;
settings.push_back(setting_frameset_value);
@ -148,7 +148,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -160,7 +160,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -168,7 +168,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -176,7 +176,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -189,7 +189,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -230,7 +230,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -271,7 +271,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -313,7 +313,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -355,7 +355,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -368,7 +368,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -376,14 +376,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -396,7 +396,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -409,7 +409,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -417,14 +417,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -434,12 +434,12 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
}
TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
std::vector<VkFrameset> input_values{
std::vector<VkFramesetEXT> input_values{
{76, 100, 10}, {1, 100, 1}
};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -456,7 +456,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count));
std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete =
@ -485,7 +485,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{

28
tests/layer/test_setting_cast.cpp
View file

@ -16,7 +16,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -30,7 +30,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count);
EXPECT_EQ(VK_TRUE, values[0]);
@ -52,7 +52,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -88,7 +88,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}};
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -124,7 +124,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -161,7 +161,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -198,7 +198,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -213,7 +213,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
uint32_t value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
@ -235,7 +235,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -250,7 +250,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
uint32_t value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -269,12 +269,12 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
}
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
std::vector<VkFrameset> input_values{
std::vector<VkFramesetEXT> input_values{
{76, 100, 10}, {1, 100, 1}
};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -285,7 +285,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VkFrameset> values(input_values.size());
std::vector<VkFramesetEXT> values(input_values.size());
uint32_t value_count = 2;
VkResult result_complete =
@ -314,7 +314,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{

110
tests/layer/test_setting_cpp.cpp
View file

@ -15,7 +15,7 @@
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
const VkBool32 value_data{VK_TRUE};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, 1, {&value_data}};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -24,10 +24,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
bool value = true;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
bool pValues = true;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(true, value);
EXPECT_EQ(true, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -37,7 +37,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -61,7 +61,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
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};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -70,10 +70,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::int32_t value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
std::int32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value);
EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -83,7 +83,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -107,7 +107,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
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};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -116,10 +116,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::uint32_t value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
std::uint32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value);
EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -129,7 +129,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
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}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -153,7 +153,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
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};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -162,10 +162,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::int64_t value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
std::int64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value);
EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -175,7 +175,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -199,7 +199,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
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};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -208,10 +208,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::uint64_t value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
std::uint64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value);
EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -221,7 +221,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -245,7 +245,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
const float value_data{-82.5f};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, 1, {&value_data}};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -254,10 +254,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
float value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
float pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(value - -82.5f) <= 0.0001f);
EXPECT_TRUE(std::abs(pValues - -82.5f) <= 0.0001f);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -267,7 +267,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -291,7 +291,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
const double value_data{-82.5};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, 1, {&value_data}};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -300,10 +300,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
double value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
double pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(value - -82.5) <= 0.0001);
EXPECT_TRUE(std::abs(pValues - -82.5) <= 0.0001);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -313,7 +313,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -337,16 +337,16 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) {
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};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
EXPECT_STREQ("VALUE_A", value.c_str());
std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -356,7 +356,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -365,9 +365,9 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
EXPECT_STREQ("VALUE_A,VALUE_B", value.c_str());
std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A,VALUE_B", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
@ -377,7 +377,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -398,9 +398,9 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
}
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) {
const VkFrameset value_data{76, 100, 10};
const VkFramesetEXT value_data{76, 100, 10};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, 1, {&value_data}};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -409,24 +409,24 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
VkFrameset value;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value);
VkFramesetEXT pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value.first);
EXPECT_EQ(100, value.count);
EXPECT_EQ(10, value.step);
EXPECT_EQ(76, pValues.first);
EXPECT_EQ(100, pValues.count);
EXPECT_EQ(10, pValues.step);
vlDestroyLayerSettingSet(layerSettingSet, nullptr);
}
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
const VkFrameset values_data[] = {
const VkFramesetEXT values_data[] = {
{76, 100, 10}, {1, 100, 1}
};
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -437,7 +437,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VkFrameset> values;
std::vector<VkFramesetEXT> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0].first);
@ -456,7 +456,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}}
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
};
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));

20
tests/layer/test_setting_env.cpp
View file

@ -22,7 +22,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -30,7 +30,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -38,7 +38,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -197,7 +197,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -205,14 +205,14 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -231,7 +231,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -239,14 +239,14 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -269,7 +269,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count));
std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete =

20
tests/layer/test_setting_file.cpp
View file

@ -23,7 +23,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -31,7 +31,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -39,7 +39,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]);
@ -198,7 +198,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -206,14 +206,14 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -232,7 +232,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0;
VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
@ -240,14 +240,14 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
value_count = 1;
VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count);
value_count = 2;
VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]);
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -270,7 +270,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count));
std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1;
VkResult result_incomplete =

126
tests/layer/test_setting_util.cpp
View file

@ -72,24 +72,24 @@ TEST(test_layer_settings_util, FindDelimiter) {
}
TEST(test_layer_settings_util, Split_1Value) {
std::string value("VALUE_A");
std::vector<std::string> reault = vl::Split(value, ',');
std::string pValues("VALUE_A");
std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str());
}
TEST(test_layer_settings_util, Split_1Value_ExtraComma) {
std::string value("VALUE_A,");
std::vector<std::string> reault = vl::Split(value, ',');
std::string pValues("VALUE_A,");
std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str());
}
TEST(test_layer_settings_util, Split_2Values) {
std::string value("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(value, ',');
std::string pValues("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(2, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str());
@ -97,8 +97,8 @@ TEST(test_layer_settings_util, Split_2Values) {
}
TEST(test_layer_settings_util, Split_2Values_ExtraComma) {
std::string value("VALUE_A,VALUE_B,");
std::vector<std::string> reault = vl::Split(value, ',');
std::string pValues("VALUE_A,VALUE_B,");
std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(2, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str());
@ -106,59 +106,59 @@ TEST(test_layer_settings_util, Split_2Values_ExtraComma) {
}
TEST(test_layer_settings_util, Split_2Values_WrongSeparator) {
std::string value("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(value, ';');
std::string pValues("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(pValues, ';');
EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A,VALUE_B", reault[0].c_str());
}
TEST(test_layer_settings_util, Split_0Value) {
std::string value("");
std::vector<std::string> result = vl::Split(value, ',');
std::string pValues("");
std::vector<std::string> result = vl::Split(pValues, ',');
EXPECT_EQ(0, result.size());
}
TEST(test_layer_settings_util, TrimWhitespace_NoWhitespace) {
std::string value("VALUE_A-VALUE_B");
std::string result = vl::TrimWhitespace(value);
std::string pValues("VALUE_A-VALUE_B");
std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A-VALUE_B", result.c_str());
}
TEST(test_layer_settings_util, TrimWhitespace_space) {
{
const std::string value("VALUE_A ");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("VALUE_A ");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value(" VALUE_A");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues(" VALUE_A");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value(" VALUE_A ");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues(" VALUE_A ");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value("VALUE A");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("VALUE A");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE A", result.c_str());
}
{
const std::string value(" VALUE A ");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues(" VALUE A ");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE A", result.c_str());
}
@ -166,36 +166,36 @@ TEST(test_layer_settings_util, TrimWhitespace_space) {
TEST(test_layer_settings_util, TrimWhitespace_Whitespace) {
{
const std::string value("VALUE_A\n");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("VALUE_A\n");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value("\f\tVALUE_A");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("\f\tVALUE_A");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value("\t\vVALUE_A\n\r");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("\t\vVALUE_A\n\r");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str());
}
{
const std::string value("VALUE\tA\f");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("VALUE\tA\f");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE\tA", result.c_str());
}
{
const std::string value("\f\tVALUE\tA\t\f");
const std::string result = vl::TrimWhitespace(value);
const std::string pValues("\f\tVALUE\tA\t\f");
const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE\tA", result.c_str());
}
@ -203,29 +203,29 @@ TEST(test_layer_settings_util, TrimWhitespace_Whitespace) {
TEST(test_layer_settings_util, TrimPrefix) {
{
const std::string value("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimPrefix(value);
const std::string pValues("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test", result.c_str());
}
{
const std::string value("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimPrefix(value);
const std::string pValues("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test_pouet", result.c_str());
}
{
const std::string value("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimPrefix(value);
const std::string pValues("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test_POUET", result.c_str());
}
{
const std::string value("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimPrefix(value);
const std::string pValues("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("lunarg_test_POUET", result.c_str());
}
@ -233,29 +233,29 @@ TEST(test_layer_settings_util, TrimPrefix) {
TEST(test_layer_settings_util, TrimVendor) {
{
const std::string value("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimVendor(value);
const std::string pValues("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test", result.c_str());
}
{
const std::string value("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimVendor(value);
const std::string pValues("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_pouet", result.c_str());
}
{
const std::string value("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimVendor(value);
const std::string pValues("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_POUET", result.c_str());
}
{
const std::string value("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimVendor(value);
const std::string pValues("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_POUET", result.c_str());
}
@ -397,7 +397,7 @@ TEST(test_layer_settings_util, is_framesets) {
TEST(test_layer_settings_util, to_framesets) {
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("0");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0");
EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first);
@ -406,7 +406,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("76");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("76");
EXPECT_EQ(1, framesets.size());
EXPECT_EQ(76, framesets[0].first);
@ -415,7 +415,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2");
EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first);
@ -424,7 +424,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2,6,7");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2,6,7");
EXPECT_EQ(3, framesets.size());
EXPECT_EQ(0, framesets[0].first);
@ -441,7 +441,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2,6-7");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2,6-7");
EXPECT_EQ(2, framesets.size());
EXPECT_EQ(0, framesets[0].first);
@ -454,7 +454,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-2,60,70");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-2,60,70");
EXPECT_EQ(3, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -471,7 +471,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("10-20,60,70");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("10-20,60,70");
EXPECT_EQ(3, framesets.size());
EXPECT_EQ(10, framesets[0].first);
@ -488,7 +488,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2");
EXPECT_EQ(1, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -497,7 +497,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,0");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,0");
EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -510,7 +510,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,10-20-5");
EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -523,7 +523,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8,10-20-5");
EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -536,7 +536,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,10-20-1");
EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first);
@ -549,7 +549,7 @@ TEST(test_layer_settings_util, to_framesets) {
}
{
std::vector<VkFrameset> framesets = vl::ToFrameSets("1,2,3,4");
std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1,2,3,4");
EXPECT_EQ(4, framesets.size());
EXPECT_EQ(1, framesets[0].first);