BUILDER_VALUE(PhysicalDevice, VkDisplayModeKHR, display_mode, {})
BUILDER_VALUE(PhysicalDevice, VkDisplayPlaneCapabilitiesKHR, display_plane_capabilities, {})
+ PhysicalDevice& set_api_version(uint32_t version) {
+ properties.apiVersion = version;
+ return *this;
+ }
+
+ PhysicalDevice&& finish() { return std::move(*this); }
+
// Objects created from this physical device
std::vector<VkDevice> device_handles;
std::vector<DeviceCreateInfo> device_create_infos;
BUILDER_VALUE(TestICD, bool, supports_tooling_info_ext, false);
BUILDER_VALUE(TestICD, bool, supports_tooling_info_core, false);
// List of tooling properties that this driver 'supports'
- std::vector<VkPhysicalDeviceToolPropertiesEXT> tooling_properties;
+ BUILDER_VECTOR(TestICD, VkPhysicalDeviceToolPropertiesEXT, tooling_properties, tooling_property)
std::vector<DispatchableHandle<VkCommandBuffer>> allocated_command_buffers;
VkInstanceCreateFlags passed_in_instance_create_flags{};
platform_shim->is_during_destruction = true;
}
-TestICDHandle& FrameworkEnvironment::add_icd(TestICDDetails icd_details) noexcept {
+TestICD& FrameworkEnvironment::add_icd(TestICDDetails icd_details) noexcept {
size_t cur_icd_index = icds.size();
fs::FolderManager* folder = &get_folder(ManifestLocation::driver);
if (icd_details.discovery_type == ManifestDiscoveryType::env_var ||
#endif
}
}
- return icds.back();
+ return icds.back().get_test_icd();
}
void FrameworkEnvironment::add_implicit_layer(ManifestLayer layer_manifest, const std::string& json_name) noexcept {
FrameworkEnvironment(const FrameworkEnvironment&) = delete;
FrameworkEnvironment& operator=(const FrameworkEnvironment&) = delete;
- TestICDHandle& add_icd(TestICDDetails icd_details) noexcept;
+ TestICD& add_icd(TestICDDetails icd_details) noexcept;
void add_implicit_layer(ManifestLayer layer_manifest, const std::string& json_name) noexcept;
void add_implicit_layer(TestLayerDetails layer_details) noexcept;
void add_explicit_layer(ManifestLayer layer_manifest, const std::string& json_name) noexcept;
// a vkEnumeratePhysicalDevices call pair.
TEST(Allocation, EnumeratePhysicalDevices) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
MemoryTracker tracker;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
{
InstWrapper inst{env.vulkan_functions, tracker.get()};
ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
// allocators used on both the instance and device.
TEST(Allocation, InstanceAndDevice) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device(PhysicalDevice{"physical_device_0"}
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .finish());
MemoryTracker tracker;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
{
InstWrapper inst{env.vulkan_functions, tracker.get()};
ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
// allocators used on only the instance and not the device.
TEST(Allocation, InstanceButNotDevice) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device(PhysicalDevice{"physical_device_0"}
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .finish());
MemoryTracker tracker;
{
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
-
InstWrapper inst{env.vulkan_functions, tracker.get()};
ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
// allocators used on only the device and not the instance.
TEST(Allocation, DeviceButNotInstance) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device(PhysicalDevice{"physical_device_0"}
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .finish());
const char* layer_name = "VkLayerImplicit0";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
MemoryTracker tracker;
{
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
-
InstWrapper inst{env.vulkan_functions};
ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
// one of the out-of-memory conditions trigger.
TEST(Allocation, CreateSurfaceIntentionalAllocFail) {
FrameworkEnvironment env{FrameworkSettings{}.set_log_filter("error,warn")};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* layer_name = "VkLayerImplicit0";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// one of the out-of-memory conditions trigger.
TEST(Allocation, CreateSurfaceIntentionalAllocFailWithSettingsFilePresent) {
FrameworkEnvironment env{FrameworkSettings{}.set_log_filter("error,warn")};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* layer_name = "VkLayerImplicit0";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// may fail.
TEST(Allocation, CreateDeviceIntentionalAllocFail) {
FrameworkEnvironment env{FrameworkSettings{}.set_log_filter("error,warn")};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
- driver.physical_devices.emplace_back("physical_device_1");
- driver.physical_devices[1].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device(PhysicalDevice{"physical_device_0"}
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .finish())
+ .add_physical_device(PhysicalDevice{"physical_device_1"}
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .finish());
const char* layer_name = "VK_LAYER_VkLayerImplicit0";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
for (uint32_t i = 0; i < num_physical_devices; i++) {
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)
.icd_manifest.set_is_portability_driver(false)
- .set_library_arch(sizeof(void*) == 8 ? "64" : "32"));
- auto& driver = env.get_test_icd(i);
- driver.set_icd_api_version(VK_API_VERSION_1_1);
- driver.add_instance_extension("VK_KHR_get_physical_device_properties2");
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
- driver.physical_devices[0].add_extensions({"VK_EXT_one", "VK_EXT_two", "VK_EXT_three", "VK_EXT_four", "VK_EXT_five"});
+ .set_library_arch(sizeof(void*) == 8 ? "64" : "32"))
+ .set_icd_api_version(VK_API_VERSION_1_1)
+ .add_instance_extension("VK_KHR_get_physical_device_properties2")
+ .add_physical_device("physical_device_0")
+ .physical_devices.at(0)
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false})
+ .add_extensions({"VK_EXT_one", "VK_EXT_two", "VK_EXT_three", "VK_EXT_four", "VK_EXT_five"});
}
env.add_icd(TestICDDetails(CURRENT_PLATFORM_DUMMY_BINARY_WRONG_TYPE).set_is_fake(true));
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
VkDirectDriverLoadingInfoLUNARG ddl_info{};
ddl_info.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
- ddl_info.pfnGetInstanceProcAddr = direct_driver_icd.icd_library.get_symbol("vk_icdGetInstanceProcAddr");
+ ddl_info.pfnGetInstanceProcAddr = env.icds.back().icd_library.get_symbol("vk_icdGetInstanceProcAddr");
VkDirectDriverLoadingListLUNARG ddl_list{};
ddl_list.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
auto& driver = env.reset_icd();
for (uint32_t i = 0; i < physical_dev_count; i++) {
- driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
- driver.physical_devices[i].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
+ driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i))
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
}
MemoryTracker tracker{{false, 0, true, fail_index}};
InstanceCreateInfo inst_create_info;
ASSERT_EQ(physical_dev_count, returned_physical_count);
for (uint32_t i = 0; i < 2; i++) {
- driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(physical_dev_count));
- driver.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
+ driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(physical_dev_count))
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
physical_dev_count += 1;
}
for (uint32_t i = 0; i < 2; i++) {
auto& driver = env.get_test_icd(i);
- driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
- driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
+ driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i))
+ .add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
}
const char* layer_name = "VkLayerImplicit0";
desc1.VendorId = known_driver.vendor_id;
desc1.AdapterLuid = _LUID{10, 1000};
env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
- env.get_test_icd().set_adapterLUID(desc1.AdapterLuid);
+ env.get_test_icd(0).set_adapterLUID(desc1.AdapterLuid);
env.platform_shim->add_d3dkmt_adapter(D3DKMT_Adapter{0, _LUID{10, 1000}}.add_driver_manifest_path(env.get_icd_manifest_path()));
TEST(GetDeviceProcAddr, DebugFuncsWithTerminator) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().setup_WSI();
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
- env.get_test_icd().physical_devices.at(0).add_extensions({"VK_KHR_swapchain"});
+ auto& driver =
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).setup_WSI().add_physical_device("physical_device_0");
+ driver.physical_devices.at(0).add_extensions({"VK_KHR_swapchain"});
// Hardware doesn't support the debug extensions
// Use getDeviceProcAddr & vary enabling the debug extensions
ASSERT_NO_FATAL_FAILURE(CheckDeviceFunctions(env, true, true));
// Now set the hardware to support the extensions and run the situations again
- env.get_test_icd().physical_devices.at(0).add_extensions({"VK_EXT_debug_marker"});
- env.get_test_icd().add_instance_extension("VK_EXT_debug_utils");
+ driver.add_instance_extension("VK_EXT_debug_utils");
+ driver.physical_devices.at(0).add_extensions({"VK_EXT_debug_marker"});
// Use getDeviceProcAddr & vary enabling the debug extensions
ASSERT_NO_FATAL_FAILURE(CheckDeviceFunctions(env, false, false));
TEST(EnvVarICDOverrideSetup, TestOnlyDriverEnvVar) {
FrameworkEnvironment env{};
env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_discovery_type(ManifestDiscoveryType::env_var));
- env.get_test_icd(0).physical_devices.emplace_back("pd0");
+ env.get_test_icd(0).add_physical_device("pd0");
InstWrapper inst1{env.vulkan_functions};
FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log);
ASSERT_EQ(phys_dev_count, 1U);
for (uint32_t add = 0; add < 2; ++add) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_discovery_type(ManifestDiscoveryType::env_var));
- env.get_test_icd(add + 1).physical_devices.emplace_back("pd" + std::to_string(add) + "0");
- env.get_test_icd(add + 1).physical_devices.emplace_back("pd" + std::to_string(add) + "1");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_discovery_type(ManifestDiscoveryType::env_var))
+ .add_physical_device("pd" + std::to_string(add) + "0")
+ .add_physical_device("pd" + std::to_string(add) + "1");
}
env.debug_log.clear();
// Make sure the loader reports the correct message based on if LOADER_USE_UNSAFE_FILE_SEARCH is set or not
TEST(EnvVarICDOverrideSetup, NonSecureEnvVarLookup) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
InstWrapper inst{env.vulkan_functions};
EnvVarWrapper xdg_data_home_env_var{"XDG_DATA_HOME", "::::/tmp/goober3:/tmp/goober4/with spaces:::"};
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
EnvVarWrapper xdg_config_dirs_env_var{"XDG_CONFIG_DIRS", "bad_file.json"};
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
// Add a driver that isn't enabled with the environment variable
env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_discovery_type(ManifestDiscoveryType::env_var));
- env.get_test_icd(0).physical_devices.emplace_back("pd0");
- env.get_test_icd(0).physical_devices.emplace_back("pd1");
+ env.get_test_icd(0).add_physical_device("pd0").add_physical_device("pd1");
env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_discovery_type(ManifestDiscoveryType::add_env_var));
- env.get_test_icd(0).physical_devices.emplace_back("pd2");
+ env.get_test_icd(0).add_physical_device("pd2");
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
// Test VK_LAYER_PATH environment variable
TEST(EnvVarICDOverrideSetup, TestOnlyLayerEnvVar) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
env.platform_shim->redirect_path("/tmp/carol", env.get_folder(ManifestLocation::explicit_layer_env_var).location());
const char* layer_name = "TestLayer";
// Test VK_ADD_LAYER_PATH environment variable
TEST(EnvVarICDOverrideSetup, TestOnlyAddLayerEnvVar) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
env.platform_shim->redirect_path("/tmp/carol", env.get_folder(ManifestLocation::explicit_layer_add_env_var).location());
const char* layer_name = "TestLayer";
// Verify that the various ways to get vkGetInstanceProcAddr return the same value
TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
{
InstWrapper inst{env.vulkan_functions};
inst.create_info.set_api_version(VK_API_VERSION_1_1);
// Verify that the various ways to get vkGetDeviceProcAddr return the same value
TEST(GetProcAddr, VerifyGetDeviceProcAddr) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
inst.create_info.set_api_version(VK_API_VERSION_1_1);
// Call the function to make sure it is callable, don't care about what is returned.
TEST(GetProcAddr, GlobalFunctions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
auto& gipa = env.vulkan_functions.vkGetInstanceProcAddr;
// global entry points with NULL instance handle
// and return VK_SUCCESS to maintain previous behavior.
TEST(GetDeviceProcAddr, SwapchainFuncsWithTerminator) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().setup_WSI();
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ auto& driver =
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).setup_WSI().add_physical_device("physical_device_0");
InstWrapper inst(env.vulkan_functions);
inst.create_info.add_extension("VK_EXT_debug_utils");
if (CreateSharedSwapchainsKHR) CreateSharedSwapchainsKHR(dev.dev, 1, &info, nullptr, &swapchain);
}
+ driver.physical_devices.at(0).add_extensions({"VK_KHR_swapchain", "VK_KHR_display_swapchain", "VK_EXT_debug_marker"});
{
- env.get_test_icd().physical_devices.at(0).add_extensions(
- {"VK_KHR_swapchain", "VK_KHR_display_swapchain", "VK_EXT_debug_marker"});
-
DeviceWrapper dev{inst};
dev.create_info.add_extensions({"VK_KHR_swapchain", "VK_KHR_display_swapchain", "VK_EXT_debug_marker"});
ASSERT_NO_FATAL_FAILURE(dev.CheckCreate(phys_dev));
// Verify that the various ways to get vkGetDeviceProcAddr return the same value
TEST(GetProcAddr, PreserveLayerGettingVkCreateDeviceWithNullInstance) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("VK_LAYER_technically_buggy_layer")
TEST(LoaderHandleValidTests, BadInstEnumPhysDevices) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
instance.CheckCreate();
TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
instance.CheckCreate();
TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
instance.CheckCreate();
TEST(LoaderHandleValidTests, BadInstDestroySurface) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
+ instance.create_info.add_extension(first_ext.extensionName.c_str());
instance.CheckCreate();
auto bad_instance = get_bad_handle<VkInstance>();
TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_EXT_headless_surface");
+ instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
instance.CheckCreate();
auto bad_instance = get_bad_handle<VkInstance>();
TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
+ instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
instance.CheckCreate();
auto bad_instance = get_bad_handle<VkInstance>();
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXlibSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
InstWrapper instance(env.vulkan_functions);
instance.create_info.set_api_version(1, 1, 0);
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ Extension second_ext{"VK_KHR_display"};
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
+ instance.create_info.add_extension(first_ext.extensionName.c_str());
instance.CheckCreate();
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ Extension second_ext{"VK_KHR_display"};
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
+ instance.create_info.add_extension(first_ext.extensionName.c_str());
instance.CheckCreate();
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ Extension second_ext{"VK_KHR_display"};
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
+ instance.create_info.add_extension(first_ext.extensionName.c_str());
instance.CheckCreate();
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_headless_surface"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+ Extension second_ext{"VK_KHR_display"};
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions({first_ext, second_ext})
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
+ instance.create_info.add_extension(first_ext.extensionName.c_str());
instance.CheckCreate();
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
}
#endif // VK_USE_PLATFORM_XLIB_KHR
-TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
- FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
+InstWrapper setup_BadPhysDev_env(FrameworkEnvironment& env, std::vector<const char*> exts) {
+ std::vector<Extension> ext_modified;
+ for (const auto& ext : exts) {
+ ext_modified.push_back(Extension{ext});
+ }
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_instance_extensions(ext_modified)
+ .setup_WSI()
+ .add_physical_device("physical_device_0");
InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
+ instance.create_info.add_extensions(exts);
instance.CheckCreate();
+ return instance;
+}
+
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
+ FrameworkEnvironment env{};
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkDisplayModeCreateInfoKHR create_info = {};
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkDisplayPlaneCapabilitiesKHR caps = {};
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_display_properties2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_get_display_properties2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_display_properties2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_get_display_properties2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_display_properties2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_get_display_properties2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_display_properties2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_get_display_properties2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkDisplayPlaneInfo2KHR disp_plane_info = {};
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_surface_capabilities2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_surface");
- instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_KHR_get_surface_capabilities2"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkQueryPoolPerformanceCreateInfoKHR create_info = {};
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
uint32_t count = 0;
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
VkMultisamplePropertiesEXT props = {};
TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_acquire_drm_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_EXT_acquire_drm_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
PFN_vkAcquireDrmDisplayEXT pfn = instance.load("vkAcquireDrmDisplayEXT");
TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_acquire_drm_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_EXT_acquire_drm_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
PFN_vkGetDrmDisplayEXT pfn = instance.load("vkGetDrmDisplayEXT");
TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_direct_mode_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_EXT_direct_mode_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_direct_mode_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
PFN_vkReleaseDisplayEXT pfn = instance.load("vkReleaseDisplayEXT");
#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_acquire_xlib_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
PFN_vkAcquireXlibDisplayEXT pfn = instance.load("vkAcquireXlibDisplayEXT");
TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- Extension first_ext{"VK_KHR_surface"};
- Extension second_ext{"VK_EXT_acquire_xlib_display"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({first_ext, second_ext});
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
RROutput rrout = {};
#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
InstWrapper instance(env.vulkan_functions);
instance.CheckCreate();
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- InstWrapper instance(env.vulkan_functions);
- instance.CheckCreate();
+ auto instance = setup_BadPhysDev_env(env, {});
auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = instance.load("vkGetPhysicalDeviceToolPropertiesEXT");
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI("VK_USE_PLATFORM_METAL_EXT");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_METAL_EXT");
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI("VK_USE_PLATFORM_METAL_EXT");
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI();
instance.create_info.add_layer(wrap_objects_name);
#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
- for (auto& ext : driver.instance_extensions) {
- std::cout << ext.extensionName << "\n";
- }
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
+
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
//
TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
Extension ext{"VK_EXT_debug_utils"};
- auto& driver = env.get_test_icd();
- driver.add_instance_extensions({ext});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_instance_extensions({ext});
const char* wrap_objects_name = "WrapObjectsLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
"wrap_objects_layer.json");
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper instance(env.vulkan_functions);
instance.create_info.add_extension("VK_EXT_debug_utils");
instance.create_info.add_layer(wrap_objects_name);
TEST(ImplicitLayers, PreInstanceVersion) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 3);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .add_physical_device({})
+ .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 2, 3));
const char* implicit_layer_name = "ImplicitTestLayer";
EnvVarWrapper disable_env_var{"DISABLE_ME"};
// tested through behavior above).
TEST(ImplicitLayers, OverrideGetInstanceProcAddr) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "ImplicitTestLayer";
EnvVarWrapper disable_env_var{"DISABLE_ME"};
// Force enable with filter env var
TEST(ImplicitLayers, EnableWithFilter) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .add_physical_device({})
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* implicit_json_name_1 = "First_layer.json";
// Force disabled with new filter env var
TEST(ImplicitLayers, DisableWithFilter) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* implicit_json_name_1 = "First_layer.json";
// Force disabled with new filter env var
TEST(ImplicitLayers, DisableWithFilterWhenLayersEnableEnvVarIsActive) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* implicit_json_name_1 = "First_layer.json";
// override the disable.
TEST(ImplicitLayers, EnableAndDisableWithFilter) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* implicit_json_name_1 = "First_layer.json";
// Add 2 implicit layers with the same layer name and expect only one to be loaded.
TEST(ImplicitLayers, DuplicateLayers) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
// Meta layer that is an explicit layer
TEST(MetaLayers, ExplicitMetaLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(MetaLayers, InstanceExtensionInComponentLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
const char* regular_layer_name = "VK_LAYER_TestLayer";
const char* instance_ext_name = "VK_EXT_headless_surface";
TEST(MetaLayers, DeviceExtensionInComponentLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
const char* regular_layer_name = "VK_LAYER_TestLayer";
const char* device_ext_name = "VK_EXT_fake_dev_ext";
// Override meta layer missing disable environment variable still enables the layer
TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name(regular_layer_name)
// Override meta layer whose version is less than the api version of the instance
TEST(OverrideMetaLayer, OlderVersionThanInstance) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name(regular_layer_name)
TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* automatic_regular_layer_name = "VK_LAYER_TestLayer_1";
const char* manual_regular_layer_name = "VK_LAYER_TestLayer_2";
TEST(OverrideMetaLayer, BasicOverridePaths) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
const char* regular_layer_name = "VK_LAYER_TestLayer_1";
TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
const char* regular_layer_name = "VK_LAYER_TestLayer";
TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// add explicit layer to VK_LAYER_PATH folder
const char* env_var_layer_name = "VK_LAYER_env_var_set_path";
// Make sure that implicit layers not in the override paths aren't found by mistake
TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
const char* implicit_layer_name = "VK_LAYER_ImplicitLayer";
TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
const char* regular_layer_name = "VK_LAYER_TestLayer_1";
// app_key contains test executable name, should activate the override layer
TEST(OverrideMetaLayer, AppKeysDoesContainCurrentApplication) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
// app_key contains random strings, should not activate the override layer
TEST(OverrideMetaLayer, AppKeysDoesNotContainCurrentApplication) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromSecureLocation) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
// Override layer should not be found and thus not loaded when running with elevated privileges
TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromUnsecureLocation) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
// succeeds and doesn't crash.
TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .add_physical_device({})
+ .set_icd_api_version(VK_API_VERSION_1_1);
const char* regular_layer_name = "TestLayer";
env.add_explicit_layer(
TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .add_physical_device({})
+ .add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
const char* regular_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
TEST(ExplicitLayers, MultipleLayersInSingleManifest) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(ExplicitLayers, WrapObjects) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
const char* wrap_objects_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(ManifestLayer{}.add_layer(
ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
"regular_layer_2.json");
- driver.physical_devices.emplace_back("physical_device_0");
{ // just the wrap layer
InstWrapper inst{env.vulkan_functions};
inst.create_info.add_layer(wrap_objects_name);
TEST(ExplicitLayers, VkLayerPathEnvVar) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
{
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
TEST(ExplicitLayers, DuplicateLayersInVK_LAYER_PATH) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(ExplicitLayers, DuplicateLayersInVK_ADD_LAYER_PATH) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayers) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayersFromSystemLocations) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(ExplicitLayers, CorrectOrderOfApplicationEnabledLayers) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
// verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
const char* layer_name_1 = "VK_LAYER_RegularLayer1";
TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
TEST(LayerExtensions, ImplicitBothInstanceExtensions) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(LayerExtensions, ExplicitBothInstanceExtensions) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
VkPhysicalDevice phys_dev = inst.GetPhysDev();
-
- uint32_t extension_count = 0;
- std::vector<VkExtensionProperties> extension_props;
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
- if (extension_count > 0) {
- extension_props.resize(extension_count);
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
- extension_props.data()));
-
- // Make sure the extensions that are implemented only in the test layers is not present.
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- ASSERT_NE(0, strcmp(extension_props[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
- ASSERT_NE(0, strcmp(extension_props[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
- }
- }
+ ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
// Device functions queried using vkGetInstanceProcAddr should be non-NULL since this could be available for any attached
// physical device.
TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
VkPhysicalDevice phys_dev = inst.GetPhysDev();
-
- uint32_t extension_count = 0;
- std::vector<VkExtensionProperties> extension_props;
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
- ASSERT_EQ(extension_count, 1U);
- extension_props.resize(extension_count);
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
- extension_props.data()));
-
- // Make sure only the one extension implemented by the enabled implicit layer is present.
- bool found = false;
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- if (!strcmp(extension_props[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
- found = true;
- }
- ASSERT_NE(0, strcmp(extension_props[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
- }
- ASSERT_EQ(true, found);
+ auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1);
+ ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
DeviceWrapper dev{inst};
dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
VkPhysicalDevice phys_dev = inst.GetPhysDev();
-
- uint32_t extension_count = 0;
- std::vector<VkExtensionProperties> extension_props;
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
- ASSERT_EQ(extension_count, 1U);
- extension_props.resize(extension_count);
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
- extension_props.data()));
-
- // Make sure only the one extension implemented by the enabled implicit layer is present.
- bool found = false;
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- ASSERT_NE(0, strcmp(extension_props[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
- if (!strcmp(extension_props[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) {
- found = true;
- }
- }
- ASSERT_EQ(true, found);
+ auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1);
+ ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
DeviceWrapper dev{inst};
dev.create_info.add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
TEST(LayerExtensions, ImplicitBothDeviceExtensions) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
const char* enable_env_var = "ENABLE_ME";
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
VkPhysicalDevice phys_dev = inst.GetPhysDev();
-
- uint32_t extension_count = 0;
- std::vector<VkExtensionProperties> extension_props;
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
- ASSERT_EQ(extension_count, 2U);
- extension_props.resize(extension_count);
- ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
- extension_props.data()));
-
- // Make sure only the one extension implemented by the enabled implicit layer is present.
- bool found[2] = {false, false};
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- if (!strcmp(extension_props[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
- found[0] = true;
- }
- if (!strcmp(extension_props[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) {
- found[1] = true;
- }
- }
- for (uint32_t ext = 0; ext < 2; ++ext) {
- ASSERT_EQ(true, found[ext]);
- }
+ auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 2);
+ ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
+ ASSERT_TRUE(string_eq(device_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
DeviceWrapper dev{inst};
dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME).add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(LayerExtensions, ExplicitBothDeviceExtensions) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ uint32_t api_version = VK_API_VERSION_1_2;
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
+ .set_icd_api_version(api_version)
+ .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
const char* regular_layer_name = "VK_LAYER_TestLayer1";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ uint32_t api_version = VK_API_VERSION_1_2;
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
+ .set_icd_api_version(api_version)
+ .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
const char* regular_layer_name = "VK_LAYER_TestLayer1";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(TestLayers, ImplicitLayerPre10APIVersion) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ uint32_t api_version = VK_API_VERSION_1_2;
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
+ .set_icd_api_version(api_version)
+ .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
const char* regular_layer_name = "VK_LAYER_TestLayer1";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// it is set with VK_INSTANCE_LAYERS
TEST(TestLayers, InstEnvironEnableExplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ uint32_t api_version = VK_API_VERSION_1_2;
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
+ .set_icd_api_version(api_version)
+ .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
inst1.CheckCreate();
VkPhysicalDevice phys_dev1 = inst1.GetPhysDev();
- // Make sure the extensions in the layer aren't present
- uint32_t extension_count = 40;
- std::array<VkExtensionProperties, 40> extensions;
- EXPECT_EQ(VK_SUCCESS,
- env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev1, nullptr, &extension_count, extensions.data()));
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- if (string_eq(extensions[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME) ||
- string_eq(extensions[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) {
- FAIL() << "Extension should not be present";
- }
- }
+ ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0));
// Create a device and query the function pointers
DeviceWrapper dev1{inst1};
// it is set with VK_LOADER_LAYERS_ENABLE
TEST(TestLayers, EnvironLayerEnableExplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ uint32_t api_version = VK_API_VERSION_1_2;
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
+ .set_icd_api_version(api_version)
+ .add_physical_device(PhysicalDevice{});
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
// it is set with VK_LOADER_LAYERS_DISABLE
TEST(TestLayers, EnvironLayerDisableExplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2)
+ .add_physical_device(PhysicalDevice{});
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
// enabled)
TEST(TestLayers, EnvironLayerEnableDisableExplicitLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
// enabled)
TEST(TestLayers, EnvironVkInstanceLayersAndDisableFilters) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
// Verify that layers enabled through VK_INSTANCE_LAYERS which were not found get the proper error message
TEST(TestLayers, NonExistantLayerInVK_INSTANCE_LAYERS) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* layer_name = "VK_LAYER_test_layer";
env.add_explicit_layer(
// Verify that if the same layer appears twice in VK_INSTANCE_LAYERS nothing bad happens
TEST(TestLayers, DuplicatesInEnvironVK_INSTANCE_LAYERS) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* layer_name = "VK_LAYER_test_layer";
env.add_explicit_layer(
TEST(TestLayers, AppEnabledExplicitLayerFails) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilter) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
TEST(TestLayers, OverrideBlacklistedLayerWithEnableFilter) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2);
const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
const char* explicit_json_name_1 = "First_layer.json";
// Add a device layer, should not work
TEST(TestLayers, DoNotUseDeviceLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2)
+ .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
VkPhysicalDevice phys_dev1 = inst1.GetPhysDev();
// Make sure the extensions in the layer aren't present
- uint32_t extension_count = 40;
- std::array<VkExtensionProperties, 40> extensions;
- EXPECT_EQ(VK_SUCCESS,
- env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev1, nullptr, &extension_count, extensions.data()));
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- if (string_eq(extensions[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME) ||
- string_eq(extensions[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) {
- FAIL() << "Extension should not be present";
- }
- }
+ ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0));
// Create a device and query the function pointers
DeviceWrapper dev1{inst1};
VkPhysicalDevice phys_dev2 = inst2.GetPhysDev();
// Make sure the extensions in the layer aren't present
- extension_count = 40;
- EXPECT_EQ(VK_SUCCESS,
- env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev1, nullptr, &extension_count, extensions.data()));
- for (uint32_t ext = 0; ext < extension_count; ++ext) {
- if (string_eq(extensions[ext].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME) ||
- string_eq(extensions[ext].extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)) {
- FAIL() << "Extension should not be present";
- }
- }
+ ASSERT_NO_FATAL_FAILURE(inst2.EnumerateDeviceExtensions(phys_dev2, 0));
DeviceWrapper dev2{inst2};
dev2.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)
// Make sure that a layer enabled as both an instance and device layer works properly.
TEST(TestLayers, InstanceAndDeviceLayer) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2)
+ .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
env.add_explicit_layer(
// Make sure loader does not throw an error for a device layer that is not present
TEST(TestLayers, DeviceLayerNotPresent) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
- env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
- VkPhysicalDeviceProperties properties{};
- properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
- env.get_test_icd().add_physical_device({});
- env.get_test_icd().physical_devices.back().set_properties(properties);
-
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
+ .set_icd_api_version(VK_API_VERSION_1_2)
+ .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
InstWrapper inst{env.vulkan_functions};
layer.set_add_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_remove_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_reorder_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_add_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_remove_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_reorder_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true);
for (uint32_t icd = 0; icd < 2; ++icd) {
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& cur_icd = env.get_test_icd(icd);
- cur_icd.icd_api_version = VK_API_VERSION_1_2;
+ auto& cur_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_icd_api_version(VK_API_VERSION_1_2);
VkPhysicalDeviceProperties properties{};
properties.apiVersion = VK_API_VERSION_1_2;
properties.vendorID = 0x11000000 + (icd << 6);
TEST(CreateInstance, BasicRun) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd();
- driver.set_min_icd_interface_version(5);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(EnumerateDeviceLayerProperties, LayersMatch) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "TestLayer";
env.add_explicit_layer(
TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
std::array<Extension, 2> device_extensions = {Extension{"MyExtension0", 4}, Extension{"MyExtension1", 7}};
for (auto& ext : device_extensions) {
TEST(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
std::array<Extension, 2> device_extensions = {Extension{"MyExtension0", 4}, Extension{"MyExtension1", 7}};
for (auto& ext : device_extensions) {
TEST(EnumerateDeviceExtensionProperties, ZeroPhysicalDeviceExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
- env.get_test_icd().add_physical_device({});
InstWrapper inst{env.vulkan_functions};
inst.create_info.set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
inst.CheckCreate(VK_SUCCESS);
TEST(EnumerateDeviceExtensionProperties, ImplicitLayerPresentNoExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+ std::vector<Extension> exts = {Extension{"MyDriverExtension0", 4}, Extension{"MyDriverExtension1", 7},
+ Extension{"MyDriverExtension2", 6}, Extension{"MyDriverExtension3", 10}};
+
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .add_physical_device("physical_device_0")
+ .physical_devices.at(0)
+ .add_extensions(exts);
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("implicit_layer_name")
.set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
.set_disable_environment("DISABLE_ME")),
"implicit_test_layer.json");
- std::vector<Extension> exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
- driver.physical_devices.front().extensions.emplace_back("MyDriverExtension0", 4);
- driver.physical_devices.front().extensions.emplace_back("MyDriverExtension1", 7);
- driver.physical_devices.front().extensions.emplace_back("MyDriverExtension2", 6);
- driver.physical_devices.front().extensions.emplace_back("MyDriverExtension3", 10);
-
- exts.insert(exts.begin(), driver.physical_devices.front().extensions.begin(), driver.physical_devices.front().extensions.end());
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
- VkPhysicalDevice physical_device = inst.GetPhysDev();
- exercise_EnumerateDeviceExtensionProperties(inst, physical_device, exts);
+ exercise_EnumerateDeviceExtensionProperties(inst, inst.GetPhysDev(), exts);
}
TEST(EnumerateDeviceExtensionProperties, ImplicitLayerPresentWithExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension0", 4);
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension1", 7);
TEST(EnumerateDeviceExtensionProperties, ImplicitLayerPresentWithLotsOfExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension0", 4);
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension1", 7);
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension2", 6);
TEST(EnumerateDeviceExtensionProperties, NoDriverExtensionsImplicitLayerPresentWithExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(EnumerateDeviceExtensionProperties, NoDriverExtensionsImplicitLayerPresentWithLotsOfExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(EnumerateDeviceExtensionProperties, ImplicitLayerPresentWithDuplicateExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension0", 4);
driver.physical_devices.front().extensions.emplace_back("MyDriverExtension1", 7);
TEST(EnumerateDeviceExtensionProperties, ImplicitLayerPresentWithOnlyDuplicateExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
std::vector<Extension> exts;
std::vector<ManifestLayer::LayerDescription::Extension> layer_exts;
auto& layer = env.get_test_layer();
layer.device_extensions = exts;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
driver.physical_devices.front().extensions = exts;
InstWrapper inst{env.vulkan_functions};
TEST(EnumeratePhysicalDevices, OneCall) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
-
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices.emplace_back("physical_device_1");
- driver.physical_devices.emplace_back("physical_device_2");
- driver.physical_devices.emplace_back("physical_device_3");
+ driver.add_physical_device("physical_device_0");
+ driver.add_physical_device("physical_device_1");
+ driver.add_physical_device("physical_device_2");
+ driver.add_physical_device("physical_device_3");
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(EnumeratePhysicalDevices, TwoCall) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
const uint32_t real_device_count = 2;
for (uint32_t i = 0; i < real_device_count; i++) {
- driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
+ driver.add_physical_device(std::string("physical_device_") + std::to_string(i));
driver.physical_devices.back().extensions.push_back({VK_EXT_PCI_BUS_INFO_EXTENSION_NAME, 0});
}
TEST(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.set_min_icd_interface_version(5);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
const uint32_t real_device_count = 3;
for (uint32_t i = 0; i < real_device_count; i++) {
- driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
+ driver.add_physical_device(std::string("physical_device_") + std::to_string(i));
driver.physical_devices.back().extensions.push_back({VK_EXT_PCI_BUS_INFO_EXTENSION_NAME, 0});
}
TEST(EnumeratePhysicalDevices, TwoCallIncomplete) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
const uint32_t real_device_count = 2;
for (uint32_t i = 0; i < real_device_count; i++) {
TEST(EnumeratePhysicalDevices, ZeroPhysicalDevicesAfterCreateInstance) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
InstWrapper inst{env.vulkan_functions};
inst.create_info.set_api_version(VK_API_VERSION_1_1);
inst.CheckCreate();
TEST(EnumeratePhysicalDevices, CallTwiceNormal) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
for (size_t i = 0; i < 4; i++) {
driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
TEST(EnumeratePhysicalDevices, CallTwiceIncompleteOnceNormal) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
for (size_t i = 0; i < 8; i++) {
driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
TEST(EnumeratePhysicalDevices, CallThriceSuccessReduce) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
for (size_t i = 0; i < 8; i++) {
driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
TEST(EnumeratePhysicalDevices, CallThriceAddInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
driver.physical_devices.emplace_back("physical_device_0");
driver.physical_devices.emplace_back("physical_device_1");
TEST(EnumeratePhysicalDevices, CallThriceRemoveInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
for (size_t i = 0; i < 4; i++) {
driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
TEST(EnumeratePhysicalDevices, MultipleAddRemoves) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).set_min_icd_interface_version(5);
for (size_t i = 0; i < 4; i++) {
driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
TEST(CreateDevice, ExtensionNotPresent) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers-devicelayerdeprecation
TEST(CreateDevice, LayersNotPresent) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers-devicelayerdeprecation
TEST(CreateDevice, MatchInstanceAndDeviceLayers) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "TestLayer";
env.add_explicit_layer(
// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers-devicelayerdeprecation
TEST(CreateDevice, UnmatchInstanceAndDeviceLayers) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "TestLayer";
env.add_explicit_layer(
// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers-devicelayerdeprecation
TEST(CreateDevice, CheckCopyOfInstanceLayerNames) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "TestLayer";
env.add_explicit_layer(
TEST(CreateDevice, ConsecutiveCreate) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
for (uint32_t i = 0; i < 100; i++) {
driver.physical_devices.emplace_back("physical_device_0");
TEST(CreateDevice, ConsecutiveCreateWithoutDestruction) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
for (uint32_t i = 0; i < 100; i++) {
driver.physical_devices.emplace_back("physical_device_0");
TEST(TryLoadWrongBinaries, WrongICD) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
env.add_icd(TestICDDetails(CURRENT_PLATFORM_DUMMY_BINARY_WRONG_TYPE).set_is_fake(true));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
InstWrapper inst{env.vulkan_functions};
TEST(TryLoadWrongBinaries, WrongExplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "DummyLayerExplicit";
env.add_fake_explicit_layer(
TEST(TryLoadWrongBinaries, WrongImplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "DummyLayerImplicit0";
env.add_fake_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(TryLoadWrongBinaries, WrongExplicitAndImplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name_0 = "DummyLayerExplicit";
env.add_fake_explicit_layer(
TEST(TryLoadWrongBinaries, WrongExplicitAndImplicitErrorOnly) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name_0 = "DummyLayerExplicit";
env.add_fake_explicit_layer(
TEST(TryLoadWrongBinaries, BadExplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "DummyLayerExplicit";
env.add_fake_explicit_layer(
TEST(TryLoadWrongBinaries, BadImplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name = "DummyLayerImplicit0";
env.add_fake_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(TryLoadWrongBinaries, BadExplicitAndImplicit) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
const char* layer_name_0 = "DummyLayerExplicit";
env.add_fake_explicit_layer(
TEST(TryLoadWrongBinaries, WrongArchDriver) {
FrameworkEnvironment env{};
// Intentionally set the wrong arch
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2}.icd_manifest.set_library_arch(sizeof(void*) == 4 ? "64" : "32"));
-
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2}.icd_manifest.set_library_arch(sizeof(void*) == 4 ? "64" : "32"))
+ .add_physical_device("physical_device_0");
DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
InstWrapper inst{env.vulkan_functions};
TEST(TryLoadWrongBinaries, WrongArchLayer) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2});
- env.get_test_icd().physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2}).add_physical_device("physical_device_0");
const char* layer_name = "TestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(EnumeratePhysicalDeviceGroups, OneCall) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
// ICD contains 3 devices in two groups
for (size_t i = 0; i < 3; i++) {
TEST(EnumeratePhysicalDeviceGroups, TwoCall) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
// ICD contains 3 devices in two groups
for (size_t i = 0; i < 3; i++) {
TEST(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
// ICD contains 3 devices in two groups
for (size_t i = 0; i < 3; i++) {
// vkEnumeratePhysicalDeviceGroupsKHR, and make sure they return the same info.
TEST(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
- driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
- driver.add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1)
+ .add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME})
+ .add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
// Generate the devices
for (size_t i = 0; i < 6; i++) {
// querying vkEnumeratePhysicalDeviceGroups before and after the add.
TEST(EnumeratePhysicalDeviceGroups, CallThriceAddGroupInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1);
// Generate the devices
for (size_t i = 0; i < 7; i++) {
// querying vkEnumeratePhysicalDeviceGroups before and after the remove.
TEST(EnumeratePhysicalDeviceGroups, CallTwiceRemoveGroupInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1);
// Generate the devices
for (size_t i = 0; i < 7; i++) {
// querying vkEnumeratePhysicalDeviceGroups before and after the add.
TEST(EnumeratePhysicalDeviceGroups, CallTwiceAddDeviceInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1);
// Generate the devices
for (size_t i = 0; i < 7; i++) {
// querying vkEnumeratePhysicalDeviceGroups before and after the remove.
TEST(EnumeratePhysicalDeviceGroups, CallTwiceRemoveDeviceInBetween) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1);
// Generate the devices
for (size_t i = 0; i < 6; i++) {
// various devices and groups while querying in between.
TEST(EnumeratePhysicalDeviceGroups, MultipleAddRemoves) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .set_min_icd_interface_version(5)
+ .set_icd_api_version(VK_API_VERSION_1_1);
// Generate the devices
for (size_t i = 0; i < 9; i++) {
"No-Layer"};
{ // No support in driver
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
}
{ // extension is supported in driver
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().supports_tooling_info_ext = true;
- env.get_test_icd().tooling_properties.push_back(icd_tool_props);
- env.get_test_icd().physical_devices.back().extensions.push_back({VK_EXT_TOOLING_INFO_EXTENSION_NAME, 0});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .set_supports_tooling_info_ext(true)
+ .add_tooling_property(icd_tool_props)
+ .add_physical_device(PhysicalDevice{}.add_extension(VK_EXT_TOOLING_INFO_EXTENSION_NAME).finish());
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
}
{ // core
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- env.get_test_icd().physical_devices.back().properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 3, 0);
- env.get_test_icd().supports_tooling_info_core = true;
- env.get_test_icd().tooling_properties.push_back(icd_tool_props);
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
+ .add_physical_device({})
+ .set_supports_tooling_info_core(true)
+ .add_tooling_property(icd_tool_props)
+ .physical_devices.back()
+ .properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 3, 0);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(PortabilityICDConfiguration, PortabilityICDOnly) {
FrameworkEnvironment env{};
env.add_icd(
- TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_is_portability_driver(true)));
-
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.max_icd_interface_version = 1;
+ TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_is_portability_driver(true)))
+ .add_physical_device("physical_device_0")
+ .set_max_icd_interface_version(1);
{ // enable portability extension and flag
InstWrapper inst{env.vulkan_functions};
inst.create_info.add_extension(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
TEST(PortabilityICDConfiguration, PortabilityAndRegularICDPreInstanceFunctions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)));
- env.add_icd(
- TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_is_portability_driver(true)));
-
Extension first_ext{"VK_EXT_validation_features"}; // known instance extensions
Extension second_ext{"VK_EXT_headless_surface"};
- env.get_test_icd().add_instance_extensions({first_ext, second_ext});
-
- auto& driver0 = env.get_test_icd(0);
- auto& driver1 = env.get_test_icd(1);
-
- driver0.physical_devices.emplace_back("physical_device_0");
- driver0.max_icd_interface_version = 1;
-
- driver1.physical_devices.emplace_back("portability_physical_device_1");
- driver1.max_icd_interface_version = 1;
+ env.add_icd(TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)))
+ .add_physical_device("physical_device_0")
+ .set_max_icd_interface_version(1)
+ .add_instance_extensions({first_ext, second_ext});
+ env.add_icd(
+ TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_is_portability_driver(true)))
+ .add_physical_device("portability_physical_device_1")
+ .set_max_icd_interface_version(1);
{
// check that enumerating instance extensions work with a portability driver present
auto extensions = env.GetInstanceExtensions(6);
#if defined(_WIN32)
TEST(AppPackageDriverDiscovery, AppPackageTest) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2}.set_discovery_type(ManifestDiscoveryType::windows_app_package));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2}.set_discovery_type(ManifestDiscoveryType::windows_app_package))
+ .add_physical_device({});
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
auto null_path = env.get_folder(ManifestLocation::null).location() / "test_icd_0.json";
env.platform_shim->add_manifest(ManifestCategory::icd, null_path.str());
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA}.set_discovery_type(ManifestDiscoveryType::null_dir));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.adapterLUID = _LUID{10, 1000};
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA}.set_discovery_type(ManifestDiscoveryType::null_dir))
+ .add_physical_device("physical_device_0")
+ .set_adapterLUID(_LUID{10, 1000});
env.platform_shim->add_d3dkmt_adapter(D3DKMT_Adapter{0, _LUID{10, 1000}}.add_driver_manifest_path(env.get_icd_manifest_path()));
InstWrapper inst{env.vulkan_functions};
EnvVarWrapper ld_library_path("LD_LIBRARY_PATH", env.get_folder(ManifestLocation::driver).location().str());
ld_library_path.add_to_list(env.get_folder(ManifestLocation::explicit_layer).location().str());
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2).set_use_dynamic_library_default_search_paths(true));
- env.get_test_icd().physical_devices.push_back({});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2).set_use_dynamic_library_default_search_paths(true))
+ .add_physical_device({});
const char* fake_ext_name = "VK_FAKE_extension";
- env.get_test_icd().physical_devices.back().add_extension(fake_ext_name);
+ driver.physical_devices.back().add_extension(fake_ext_name);
const char* layer_name = "TestLayer";
env.add_explicit_layer(
// Check that valid symlinks do not cause the loader to crash when directly in an XDG env-var
TEST(ManifestDiscovery, ValidSymlinkInXDGEnvVar) {
FrameworkEnvironment env{FrameworkSettings{}.set_enable_default_search_paths(false)};
- env.add_icd(
- TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_discovery_type(ManifestDiscoveryType::override_folder));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_discovery_type(ManifestDiscoveryType::override_folder))
+ .add_physical_device({});
auto driver_path = env.get_icd_manifest_path(0);
std::string symlink_name = "symlink_to_driver.json";
fs::path symlink_path = env.get_folder(ManifestLocation::driver_env_var).location() / symlink_name;
// Check that valid symlinks do not cause the loader to crash
TEST(ManifestDiscovery, ValidSymlink) {
FrameworkEnvironment env{FrameworkSettings{}.set_enable_default_search_paths(false)};
- env.add_icd(
- TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_discovery_type(ManifestDiscoveryType::override_folder));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_discovery_type(ManifestDiscoveryType::override_folder))
+ .add_physical_device({});
auto driver_path = env.get_icd_manifest_path(0);
std::string symlink_name = "symlink_to_driver.json";
TEST(LayerCreatesDevice, Basic) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("implicit_layer_name")
TEST(Layer, pfnNextGetInstanceProcAddr_should_not_return_layers_own_functions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd(0).physical_devices.emplace_back("Device0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("implicit_layer_name")
// Make sure settings layer is found and that a layer defined in it is loaded
TEST(SettingsFile, FileExist) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer_0";
env.add_explicit_layer(TestLayerDetails{
ManifestLayer{}.add_layer(
// Make sure that if the settings file is in a user local path, that it isn't used when running with elevated privileges
TEST(SettingsFile, SettingsInUnsecuredLocation) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* regular_layer_name = "VK_LAYER_TestLayer_0";
env.add_explicit_layer(TestLayerDetails{
ManifestLayer{}.add_layer(
TEST(SettingsFile, SettingsInSecuredLocation) {
FrameworkEnvironment env{FrameworkSettings{}.set_secure_loader_settings(true)};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
const char* regular_layer_name = "VK_LAYER_TestLayer_0";
env.add_explicit_layer(TestLayerDetails{
.set_name(global_layer_name)
.set_path(env.get_layer_manifest_path(1).str())
.set_control("on"))));
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
{
auto layer_props = env.GetLayerProperties(1);
EXPECT_TRUE(string_eq(layer_props.at(0).layerName, global_layer_name));
TEST(SettingsFile, LayerAutoEnabledByEnvVars) {
FrameworkEnvironment env{};
env.loader_settings.set_file_format_version({1, 0, 0});
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* layer_name = "VK_LAYER_automatic";
env.add_explicit_layer(
// Make sure layers are disallowed from loading if the settings file says so
TEST(SettingsFile, LayerDisablesImplicitLayer) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_Implicit_TestLayer";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name(implicit_layer_name)
// Implicit layers should be reordered by the settings file
TEST(SettingsFile, ImplicitLayersDontInterfere) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* implicit_layer_name1 = "VK_LAYER_Implicit_TestLayer1";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name(implicit_layer_name1)
// Make sure layers that are disabled can't be enabled by the application
TEST(SettingsFile, ApplicationEnablesIgnored) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
ManifestLayer{}.add_layer(
TEST(SettingsFile, LayerListIsEmpty) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_TestLayer";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name(implicit_layer_name)
// If a settings file exists but contains no valid settings - don't consider it
TEST(SettingsFile, InvalidSettingsFile) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
ManifestLayer{}.add_layer(
// Unknown layers are put in the correct location
TEST(SettingsFile, UnknownLayersInRightPlace) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name1 = "VK_LAYER_TestLayer1";
env.add_explicit_layer(
ManifestLayer{}.add_layer(
// Settings file allows loading multiple layers with the same name - as long as the path is different
TEST(SettingsFile, MultipleLayersWithSameName) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// Settings file shouldn't be able to cause the same layer from the same path twice
TEST(SettingsFile, MultipleLayersWithSamePath) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_TestLayer";
env.add_explicit_layer(
// file is removed
TEST(SettingsFile, MismatchedLayerNameAndManifestPath) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* manifest_explicit_layer_name = "VK_LAYER_MANIFEST_TestLayer";
const char* settings_explicit_layer_name = "VK_LAYER_Settings_TestLayer";
// Settings file should take precedence over the meta layer, if present
TEST(SettingsFile, MetaLayerAlsoActivates) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* settings_explicit_layer_name = "VK_LAYER_Regular_TestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// Layers are correctly ordered by settings file.
TEST(SettingsFile, LayerOrdering) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name1 = "VK_LAYER_Regular_TestLayer1";
env.add_explicit_layer(
TEST(SettingsFile, EnvVarsWork_VK_LAYER_PATH) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name1 = "VK_LAYER_Regular_TestLayer1";
env.add_explicit_layer(TestLayerDetails{
TEST(SettingsFile, EnvVarsWork_VK_ADD_LAYER_PATH) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* implicit_layer_name1 = "VK_LAYER_Implicit_TestLayer1";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(SettingsFile, EnvVarsWork_VK_INSTANCE_LAYERS) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_Regular_TestLayer1";
env.add_explicit_layer(TestLayerDetails{
// Make sure that layers disabled by settings file aren't enabled by VK_LOADER_LAYERS_ENABLE
TEST(SettingsFile, EnvVarsWork_VK_LOADER_LAYERS_ENABLE) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_Regular_TestLayer1";
env.add_explicit_layer(TestLayerDetails{
// Make sure that layers enabled by settings file aren't disabled by VK_LOADER_LAYERS_ENABLE
TEST(SettingsFile, EnvVarsWork_VK_LOADER_LAYERS_DISABLE) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "VK_LAYER_Regular_TestLayer1";
env.add_explicit_layer(TestLayerDetails{
#if defined(WIN32)
TEST(SettingsFile, MultipleKeysInRegistryInUnsecureLocation) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.platform_shim->add_unsecured_manifest(ManifestCategory::settings, "jank_path");
env.platform_shim->add_unsecured_manifest(ManifestCategory::settings, "jank_path2");
TEST(SettingsFile, MultipleKeysInRegistryInSecureLocation) {
FrameworkEnvironment env{FrameworkSettings{}.set_secure_loader_settings(true)};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.platform_shim->add_manifest(ManifestCategory::settings, "jank_path");
env.platform_shim->add_manifest(ManifestCategory::settings, "jank_path2");
// Preinstance functions respect the settings file
TEST(SettingsFile, PreInstanceFunctions) {
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer";
};
FrameworkEnvironment env;
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
// Settings can say which filters to use - make sure those are propagated & treated correctly
TEST(SettingsFile, StderrLogFilters) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
const char* explicit_layer_name = "Regular_TestLayer1";
env.add_explicit_layer(TestLayerDetails{
ManifestLayer{}.add_layer(
// Enough layers exist that arrays need to be resized - make sure that works
TEST(SettingsFile, TooManyLayers) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- env.get_test_icd().add_physical_device({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
env.loader_settings.set_file_format_version({1, 0, 0}).add_app_specific_setting(
AppSpecificSettings{}.add_stderr_log_filter("all"));
std::string layer_name = "VK_LAYER_regular_layer_name_";
uint32_t num_loops_try_get_proc_addr) {
InstWrapper inst{env->vulkan_functions};
inst.CheckCreate();
- VkPhysicalDevice phys_dev = inst.GetPhysDev();
for (uint32_t i = 0; i < num_loops_create_destroy_device; i++) {
DeviceWrapper dev{inst};
- dev.CheckCreate(phys_dev);
+ dev.CheckCreate(inst.GetPhysDev());
for (uint32_t j = 0; j < num_loops_try_get_proc_addr; j++) {
PFN_vkCmdBindPipeline p = dev.load("vkCmdBindPipeline");
const auto processor_count = std::thread::hardware_concurrency();
FrameworkEnvironment env{FrameworkSettings{}.set_log_filter("")};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
uint32_t num_loops_create_destroy_instance = 500;
uint32_t num_loops_try_get_instance_proc_addr = 5;
uint32_t num_loops_try_get_device_proc_addr = 100;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices.back().known_device_functions.push_back(
- {"vkCmdBindPipeline", to_vkVoidFunction(test_vkCmdBindPipeline)});
+ driver.physical_devices.emplace_back("physical_device_0")
+ .known_device_functions.push_back({"vkCmdBindPipeline", to_vkVoidFunction(test_vkCmdBindPipeline)});
std::vector<std::thread> instance_creation_threads;
std::vector<std::thread> function_query_threads;
const auto processor_count = std::thread::hardware_concurrency();
FrameworkEnvironment env{FrameworkSettings{}.set_log_filter("")};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
uint32_t num_loops_create_destroy_device = 1000;
uint32_t num_loops_try_get_device_proc_addr = 5;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices.back().known_device_functions.push_back(
- {"vkCmdBindPipeline", to_vkVoidFunction(test_vkCmdBindPipeline)});
- driver.physical_devices.back().known_device_functions.push_back(
- {"vkCmdBindDescriptorSets", to_vkVoidFunction(test_vkCmdBindDescriptorSets)});
- driver.physical_devices.back().known_device_functions.push_back(
- {"vkCmdBindVertexBuffers", to_vkVoidFunction(test_vkCmdBindVertexBuffers)});
- driver.physical_devices.back().known_device_functions.push_back(
- {"vkCmdBindIndexBuffer", to_vkVoidFunction(test_vkCmdBindIndexBuffer)});
- driver.physical_devices.back().known_device_functions.push_back({"vkCmdDraw", to_vkVoidFunction(test_vkCmdDraw)});
+ driver.physical_devices.emplace_back("physical_device_0").known_device_functions = {
+ {"vkCmdBindPipeline", to_vkVoidFunction(test_vkCmdBindPipeline)},
+ {"vkCmdBindDescriptorSets", to_vkVoidFunction(test_vkCmdBindDescriptorSets)},
+ {"vkCmdBindVertexBuffers", to_vkVoidFunction(test_vkCmdBindVertexBuffers)},
+ {"vkCmdBindIndexBuffer", to_vkVoidFunction(test_vkCmdBindIndexBuffer)},
+ {"vkCmdDraw", to_vkVoidFunction(test_vkCmdDraw)}};
std::vector<std::thread> device_creation_threads;
TEST(UnknownFunction, PhysicalDeviceFunction) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
- driver.physical_devices.emplace_back("physical_device_0");
fill_implementation_functions(driver.physical_devices.at(0).custom_physical_device_functions, function_names,
custom_physical_device_functions{}, function_count);
InstWrapper inst{env.vulkan_functions};
TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver_0 = env.get_test_icd(0);
- auto& driver_1 = env.get_test_icd(1);
+ auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
// used to identify the GPUs
- VkPhysicalDeviceProperties props{};
- driver_0.physical_devices.emplace_back("physical_device_0");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
- driver_0.physical_devices.back().set_properties(props);
- driver_1.physical_devices.emplace_back("physical_device_1");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
- driver_1.physical_devices.back().set_properties(props);
+ driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+ driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
for (uint32_t i = 0; i < function_count / 10; i++) {
fill_implementation_functions(driver_0.physical_devices.at(0).custom_physical_device_functions, function_names,
auto phys_devs = inst.GetPhysDevs(2);
VkPhysicalDevice phys_dev_0 = phys_devs[0];
VkPhysicalDevice phys_dev_1 = phys_devs[1];
+ VkPhysicalDeviceProperties props{};
env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
phys_dev_0 = phys_devs[1];
// Add unknown functions to driver 0, and try to use them on driver 1.
TEST(UnknownFunctionDeathTests, PhysicalDeviceFunctionErrorPath) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver_0 = env.get_test_icd(0);
- auto& driver_1 = env.get_test_icd(1);
+ auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
std::vector<std::string> function_names;
add_function_names(function_names, 1);
// used to identify the GPUs
- VkPhysicalDeviceProperties props{};
- driver_0.physical_devices.emplace_back("physical_device_0");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
- driver_0.physical_devices.back().set_properties(props);
- driver_1.physical_devices.emplace_back("physical_device_1");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
- driver_1.physical_devices.back().set_properties(props);
+ driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+ driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
function_names.push_back(std::string("vkNotIntRealFuncTEST_0"));
custom_physical_device_functions funcs{};
auto phys_devs = inst.GetPhysDevs(2);
VkPhysicalDevice phys_dev_to_use = phys_devs[1];
+ VkPhysicalDeviceProperties props{};
env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[1], &props);
if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) phys_dev_to_use = phys_devs[0];
// use the wrong GPU to query the functions, should get 5 errors
TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerImplementation) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
- auto& driver = env.get_test_icd();
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
- driver.physical_devices.emplace_back("physical_device_0");
-
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
.set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitLayerImplementation) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver_0 = env.get_test_icd(0);
- auto& driver_1 = env.get_test_icd(1);
+ auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
// used to identify the GPUs
- VkPhysicalDeviceProperties props{};
- driver_0.physical_devices.emplace_back("physical_device_0");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
- driver_0.physical_devices.back().set_properties(props);
- driver_1.physical_devices.emplace_back("physical_device_1");
- props.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
- driver_1.physical_devices.back().set_properties(props);
+ driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+ driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
for (uint32_t i = 0; i < function_count / 10; i++) {
fill_implementation_functions(driver_0.physical_devices.at(0).custom_physical_device_functions, function_names,
custom_physical_device_functions{}, 5, i * 10);
auto phys_devs = inst.GetPhysDevs(2);
VkPhysicalDevice phys_dev_0 = phys_devs[0];
VkPhysicalDevice phys_dev_1 = phys_devs[1];
+ VkPhysicalDeviceProperties props{};
env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
phys_dev_0 = phys_devs[1];
TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerInterception) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
TEST(UnknownFunction, PhysicalDeviceFunctionDriverSupportWithImplicitLayerInterception) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
uint32_t function_count = 100;
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
- driver.physical_devices.emplace_back("physical_device_0");
fill_implementation_functions(driver.physical_devices.at(0).custom_physical_device_functions, function_names,
layer_implementation_physical_device_functions{}, function_count);
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(UnknownFunction, PhysicalDeviceFunctionWithMultipleImplicitLayersInterception) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
std::vector<std::string> function_names;
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
add_function_names(function_names, function_count);
using layer_intercept_functions_type = layer_intercept_functions<DispatchableHandleType>;
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
-
std::vector<std::string> function_names;
add_function_names(function_names, function_count);
TEST(UnknownFunction, PhysicalDeviceFunctionTwoLayerInterception) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
-
- driver.physical_devices.emplace_back("physical_device_0");
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
PhysicalDevice& pd = driver.physical_devices.back();
UnknownFunction f{"vkFunc1"};
TEST(UnknownFunction, ManyCombinations) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+ PhysicalDevice& physical_device = driver.physical_devices.back();
std::vector<UnknownFunction> unknown_funcs;
unknown_funcs.emplace_back("vkZero_uint32_uint32_0");
unknown_funcs.emplace_back("vkOne_uint32_uint32_char_11");
unknown_funcs.emplace_back("vkTwo_ptr_int_ptr_int_12");
- driver.physical_devices.emplace_back("physical_device_0");
- PhysicalDevice& physical_device = driver.physical_devices.back();
-
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
.set_name("VK_LAYER_implicit_layer_unknown_function_intercept_0")
.set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
TEST(ICDInterfaceVersion2Plus, vk_icdNegotiateLoaderICDInterfaceVersion) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
for (uint32_t i = 0; i <= 6; i++) {
for (uint32_t j = i; j <= 6; j++) {
- driver.min_icd_interface_version = i;
- driver.max_icd_interface_version = j;
+ driver.set_min_icd_interface_version(i).set_max_icd_interface_version(j);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
}
TEST(ICDInterfaceVersion2Plus, version_3) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
{
- driver.min_icd_interface_version = 2;
- driver.enable_icd_wsi = true;
+ driver.set_min_icd_interface_version(2).set_enable_icd_wsi(true);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
ASSERT_FALSE(driver.is_using_icd_wsi);
}
{
- driver.min_icd_interface_version = 3;
- driver.enable_icd_wsi = false;
+ driver.set_min_icd_interface_version(3).set_enable_icd_wsi(false);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
ASSERT_FALSE(driver.is_using_icd_wsi);
}
{
- driver.min_icd_interface_version = 3;
- driver.enable_icd_wsi = true;
+ driver.set_min_icd_interface_version(3).set_enable_icd_wsi(true);
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
TEST(ICDInterfaceVersion2Plus, version_4) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.physical_devices.emplace_back("physical_device_0");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
}
// This test makes sure that EnumerateAdapterPhysicalDevices on drivers found in the Khronos/Vulkan/Drivers registry
TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, version_6_in_drivers_registry) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES));
- auto& driver = env.get_test_icd();
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES));
driver.physical_devices.emplace_back("physical_device_1");
driver.physical_devices.emplace_back("physical_device_0");
uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
// EnumerateAdapterPhysicalDevices
TEST(ICDInterfaceVersion2, EnumAdapters2) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA}.set_discovery_type(ManifestDiscoveryType::null_dir));
+ auto& driver =
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA}.set_discovery_type(ManifestDiscoveryType::null_dir));
InstWrapper inst{env.vulkan_functions};
- auto& driver = env.get_test_icd();
driver.physical_devices.emplace_back("physical_device_1");
driver.physical_devices.emplace_back("physical_device_0");
uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
// Verify that the handles are correct by calling vkGetPhysicalDeviceProperties with them
TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, VerifyPhysDevResults) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}.set_discovery_type(
- ManifestDiscoveryType::null_dir));
- auto& driver = env.get_test_icd();
- driver.min_icd_interface_version = 6;
- driver.set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver =
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}.set_discovery_type(
+ ManifestDiscoveryType::null_dir))
+ .set_min_icd_interface_version(6)
+ .set_icd_api_version(VK_API_VERSION_1_1);
const std::vector<std::string> physical_device_names = {"physical_device_4", "physical_device_3", "physical_device_2",
"physical_device_1", "physical_device_0"};
for (const auto& dev_name : physical_device_names) driver.physical_devices.push_back(dev_name);
desc1.VendorId = known_driver.vendor_id;
desc1.AdapterLuid = _LUID{10, 1000};
env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
- env.get_test_icd().set_adapterLUID(desc1.AdapterLuid);
+ driver.set_adapterLUID(desc1.AdapterLuid);
env.platform_shim->add_d3dkmt_adapter(D3DKMT_Adapter{0, _LUID{10, 1000}}.add_driver_manifest_path(env.get_icd_manifest_path()));
// Make sure physical device groups enumerated through EnumerateAdapterPhysicalDevices are properly found
TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, VerifyGroupResults) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}.set_discovery_type(
- ManifestDiscoveryType::null_dir));
- auto& driver = env.get_test_icd();
- driver.min_icd_interface_version = 6;
- driver.set_icd_api_version(VK_API_VERSION_1_1);
+ auto& driver =
+ env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}.set_discovery_type(
+ ManifestDiscoveryType::null_dir))
+ .set_min_icd_interface_version(6)
+ .set_icd_api_version(VK_API_VERSION_1_1);
const std::vector<std::string> physical_device_names = {"physical_device_4", "physical_device_3", "physical_device_2",
"physical_device_1", "physical_device_0"};
- for (const auto& dev_name : physical_device_names) driver.physical_devices.push_back(dev_name);
+ for (const auto& dev_name : physical_device_names) {
+ driver.physical_devices.push_back(dev_name);
+ }
- driver.physical_device_groups.emplace_back(driver.physical_devices[0]);
- driver.physical_device_groups.back().use_physical_device(driver.physical_devices[1]);
+ driver.physical_device_groups.emplace_back(driver.physical_devices[0]).use_physical_device(driver.physical_devices[1]);
driver.physical_device_groups.emplace_back(driver.physical_devices[2]);
- driver.physical_device_groups.emplace_back(driver.physical_devices[3]);
- driver.physical_device_groups.back().use_physical_device(driver.physical_devices[4]);
+ driver.physical_device_groups.emplace_back(driver.physical_devices[3]).use_physical_device(driver.physical_devices[4]);
auto& known_driver = known_driver_list.at(2); // which driver this test pretends to be
DXGI_ADAPTER_DESC1 desc1{};
desc1.VendorId = known_driver.vendor_id;
desc1.AdapterLuid = _LUID{10, 1000};
env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
- env.get_test_icd().set_adapterLUID(desc1.AdapterLuid);
+ driver.set_adapterLUID(desc1.AdapterLuid);
env.platform_shim->add_d3dkmt_adapter(D3DKMT_Adapter{0, _LUID{10, 1000}}.add_driver_manifest_path(env.get_icd_manifest_path()));
#endif // defined(WIN32)
TEST(ICDInterfaceVersion7, SingleDriver) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7_WITH_ADDITIONAL_EXPORTS));
- env.get_test_icd().physical_devices.push_back({});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7_WITH_ADDITIONAL_EXPORTS)).add_physical_device({});
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
- auto phys_dev = inst.GetPhysDev();
DeviceWrapper dev{inst};
- dev.CheckCreate(phys_dev);
- ASSERT_EQ(env.get_test_icd().interface_version_check, InterfaceVersionCheck::version_is_supported);
+ dev.CheckCreate(inst.GetPhysDev());
+ ASSERT_EQ(driver.interface_version_check, InterfaceVersionCheck::version_is_supported);
}
TEST(ICDInterfaceVersion7, SingleDriverWithoutExportedFunctions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7));
- env.get_test_icd().physical_devices.push_back({});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7)).add_physical_device({});
InstWrapper inst{env.vulkan_functions};
inst.CheckCreate();
- auto phys_dev = inst.GetPhysDev();
DeviceWrapper dev{inst};
- dev.CheckCreate(phys_dev);
- ASSERT_EQ(env.get_test_icd().interface_version_check, InterfaceVersionCheck::version_is_supported);
+ dev.CheckCreate(inst.GetPhysDev());
+ ASSERT_EQ(driver.interface_version_check, InterfaceVersionCheck::version_is_supported);
}
TEST(MultipleICDConfig, Basic) {
desc1.AdapterLuid = LUID{100 + i, static_cast<LONG>(100 + i)};
driver_6.set_adapterLUID(desc1.AdapterLuid);
env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
- env.get_test_icd().set_adapterLUID(desc1.AdapterLuid);
}
uint32_t returned_physical_count = 0;
InstWrapper inst{env.vulkan_functions};
TEST(MinorVersionUpdate, Version1_3) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
- auto& icd_phys_dev = env.get_test_icd().physical_devices.back();
- icd_phys_dev.known_device_functions.insert(
- icd_phys_dev.known_device_functions.end(),
- {
- VulkanFunction{"vkCmdBeginRendering", to_vkVoidFunction(test_vkCmdBeginRendering)},
- VulkanFunction{"vkCmdBindVertexBuffers2", to_vkVoidFunction(test_vkCmdBindVertexBuffers2)},
- VulkanFunction{"vkCmdBlitImage2", to_vkVoidFunction(test_vkCmdBlitImage2)},
- VulkanFunction{"vkCmdCopyBuffer2", to_vkVoidFunction(test_vkCmdCopyBuffer2)},
- VulkanFunction{"vkCmdCopyBufferToImage2", to_vkVoidFunction(test_vkCmdCopyBufferToImage2)},
- VulkanFunction{"vkCmdCopyImage2", to_vkVoidFunction(test_vkCmdCopyImage2)},
- VulkanFunction{"vkCmdCopyImageToBuffer2", to_vkVoidFunction(test_vkCmdCopyImageToBuffer2)},
- VulkanFunction{"vkCmdEndRendering", to_vkVoidFunction(test_vkCmdEndRendering)},
- VulkanFunction{"vkCmdPipelineBarrier2", to_vkVoidFunction(test_vkCmdPipelineBarrier2)},
- VulkanFunction{"vkCmdResetEvent2", to_vkVoidFunction(test_vkCmdResetEvent2)},
- VulkanFunction{"vkCmdResolveImage2", to_vkVoidFunction(test_vkCmdResolveImage2)},
- VulkanFunction{"vkCmdSetCullMode", to_vkVoidFunction(test_vkCmdSetCullMode)},
- VulkanFunction{"vkCmdSetDepthBiasEnable", to_vkVoidFunction(test_vkCmdSetDepthBiasEnable)},
- VulkanFunction{"vkCmdSetDepthBoundsTestEnable", to_vkVoidFunction(test_vkCmdSetDepthBoundsTestEnable)},
- VulkanFunction{"vkCmdSetDepthCompareOp", to_vkVoidFunction(test_vkCmdSetDepthCompareOp)},
- VulkanFunction{"vkCmdSetDepthTestEnable", to_vkVoidFunction(test_vkCmdSetDepthTestEnable)},
- VulkanFunction{"vkCmdSetDepthWriteEnable", to_vkVoidFunction(test_vkCmdSetDepthWriteEnable)},
- VulkanFunction{"vkCmdSetEvent2", to_vkVoidFunction(test_vkCmdSetEvent2)},
- VulkanFunction{"vkCmdSetFrontFace", to_vkVoidFunction(test_vkCmdSetFrontFace)},
- VulkanFunction{"vkCmdSetPrimitiveRestartEnable", to_vkVoidFunction(test_vkCmdSetPrimitiveRestartEnable)},
- VulkanFunction{"vkCmdSetPrimitiveTopology", to_vkVoidFunction(test_vkCmdSetPrimitiveTopology)},
- VulkanFunction{"vkCmdSetRasterizerDiscardEnable", to_vkVoidFunction(test_vkCmdSetRasterizerDiscardEnable)},
- VulkanFunction{"vkCmdSetScissorWithCount", to_vkVoidFunction(test_vkCmdSetScissorWithCount)},
- VulkanFunction{"vkCmdSetStencilOp", to_vkVoidFunction(test_vkCmdSetStencilOp)},
- VulkanFunction{"vkCmdSetStencilTestEnable", to_vkVoidFunction(test_vkCmdSetStencilTestEnable)},
- VulkanFunction{"vkCmdSetViewportWithCount", to_vkVoidFunction(test_vkCmdSetViewportWithCount)},
- VulkanFunction{"vkCmdWaitEvents2", to_vkVoidFunction(test_vkCmdWaitEvents2)},
- VulkanFunction{"vkCmdWriteTimestamp2", to_vkVoidFunction(test_vkCmdWriteTimestamp2)},
- VulkanFunction{"vkCreatePrivateDataSlot", to_vkVoidFunction(test_vkCreatePrivateDataSlot)},
- VulkanFunction{"vkDestroyPrivateDataSlot", to_vkVoidFunction(test_vkDestroyPrivateDataSlot)},
- VulkanFunction{"vkGetDeviceBufferMemoryRequirements", to_vkVoidFunction(test_vkGetDeviceBufferMemoryRequirements)},
- VulkanFunction{"vkGetDeviceImageMemoryRequirements", to_vkVoidFunction(test_vkGetDeviceImageMemoryRequirements)},
- VulkanFunction{"vkGetDeviceImageSparseMemoryRequirements",
- to_vkVoidFunction(test_vkGetDeviceImageSparseMemoryRequirements)},
- VulkanFunction{"vkGetPrivateData", to_vkVoidFunction(test_vkGetPrivateData)},
- VulkanFunction{"vkQueueSubmit2", to_vkVoidFunction(test_vkQueueSubmit2)},
- VulkanFunction{"vkSetPrivateData", to_vkVoidFunction(test_vkSetPrivateData)},
- });
- icd_phys_dev.extensions.push_back({"VK_SOME_EXT_haha"});
+ auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
+ driver.physical_devices.back().known_device_functions = {
+ VulkanFunction{"vkCmdBeginRendering", to_vkVoidFunction(test_vkCmdBeginRendering)},
+ VulkanFunction{"vkCmdBindVertexBuffers2", to_vkVoidFunction(test_vkCmdBindVertexBuffers2)},
+ VulkanFunction{"vkCmdBlitImage2", to_vkVoidFunction(test_vkCmdBlitImage2)},
+ VulkanFunction{"vkCmdCopyBuffer2", to_vkVoidFunction(test_vkCmdCopyBuffer2)},
+ VulkanFunction{"vkCmdCopyBufferToImage2", to_vkVoidFunction(test_vkCmdCopyBufferToImage2)},
+ VulkanFunction{"vkCmdCopyImage2", to_vkVoidFunction(test_vkCmdCopyImage2)},
+ VulkanFunction{"vkCmdCopyImageToBuffer2", to_vkVoidFunction(test_vkCmdCopyImageToBuffer2)},
+ VulkanFunction{"vkCmdEndRendering", to_vkVoidFunction(test_vkCmdEndRendering)},
+ VulkanFunction{"vkCmdPipelineBarrier2", to_vkVoidFunction(test_vkCmdPipelineBarrier2)},
+ VulkanFunction{"vkCmdResetEvent2", to_vkVoidFunction(test_vkCmdResetEvent2)},
+ VulkanFunction{"vkCmdResolveImage2", to_vkVoidFunction(test_vkCmdResolveImage2)},
+ VulkanFunction{"vkCmdSetCullMode", to_vkVoidFunction(test_vkCmdSetCullMode)},
+ VulkanFunction{"vkCmdSetDepthBiasEnable", to_vkVoidFunction(test_vkCmdSetDepthBiasEnable)},
+ VulkanFunction{"vkCmdSetDepthBoundsTestEnable", to_vkVoidFunction(test_vkCmdSetDepthBoundsTestEnable)},
+ VulkanFunction{"vkCmdSetDepthCompareOp", to_vkVoidFunction(test_vkCmdSetDepthCompareOp)},
+ VulkanFunction{"vkCmdSetDepthTestEnable", to_vkVoidFunction(test_vkCmdSetDepthTestEnable)},
+ VulkanFunction{"vkCmdSetDepthWriteEnable", to_vkVoidFunction(test_vkCmdSetDepthWriteEnable)},
+ VulkanFunction{"vkCmdSetEvent2", to_vkVoidFunction(test_vkCmdSetEvent2)},
+ VulkanFunction{"vkCmdSetFrontFace", to_vkVoidFunction(test_vkCmdSetFrontFace)},
+ VulkanFunction{"vkCmdSetPrimitiveRestartEnable", to_vkVoidFunction(test_vkCmdSetPrimitiveRestartEnable)},
+ VulkanFunction{"vkCmdSetPrimitiveTopology", to_vkVoidFunction(test_vkCmdSetPrimitiveTopology)},
+ VulkanFunction{"vkCmdSetRasterizerDiscardEnable", to_vkVoidFunction(test_vkCmdSetRasterizerDiscardEnable)},
+ VulkanFunction{"vkCmdSetScissorWithCount", to_vkVoidFunction(test_vkCmdSetScissorWithCount)},
+ VulkanFunction{"vkCmdSetStencilOp", to_vkVoidFunction(test_vkCmdSetStencilOp)},
+ VulkanFunction{"vkCmdSetStencilTestEnable", to_vkVoidFunction(test_vkCmdSetStencilTestEnable)},
+ VulkanFunction{"vkCmdSetViewportWithCount", to_vkVoidFunction(test_vkCmdSetViewportWithCount)},
+ VulkanFunction{"vkCmdWaitEvents2", to_vkVoidFunction(test_vkCmdWaitEvents2)},
+ VulkanFunction{"vkCmdWriteTimestamp2", to_vkVoidFunction(test_vkCmdWriteTimestamp2)},
+ VulkanFunction{"vkCreatePrivateDataSlot", to_vkVoidFunction(test_vkCreatePrivateDataSlot)},
+ VulkanFunction{"vkDestroyPrivateDataSlot", to_vkVoidFunction(test_vkDestroyPrivateDataSlot)},
+ VulkanFunction{"vkGetDeviceBufferMemoryRequirements", to_vkVoidFunction(test_vkGetDeviceBufferMemoryRequirements)},
+ VulkanFunction{"vkGetDeviceImageMemoryRequirements", to_vkVoidFunction(test_vkGetDeviceImageMemoryRequirements)},
+ VulkanFunction{"vkGetDeviceImageSparseMemoryRequirements",
+ to_vkVoidFunction(test_vkGetDeviceImageSparseMemoryRequirements)},
+ VulkanFunction{"vkGetPrivateData", to_vkVoidFunction(test_vkGetPrivateData)},
+ VulkanFunction{"vkQueueSubmit2", to_vkVoidFunction(test_vkQueueSubmit2)},
+ VulkanFunction{"vkSetPrivateData", to_vkVoidFunction(test_vkSetPrivateData)},
+ };
+ driver.physical_devices.back().add_extension({"VK_SOME_EXT_haha"});
InstWrapper inst{env.vulkan_functions};
inst.create_info.set_api_version(1, 3, 0);
inst.CheckCreate();
TEST(ApplicationInfoVersion, NonVulkanVariant) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
DebugUtilsLogger log;
InstWrapper inst{env.vulkan_functions};
TEST(DriverManifest, NonVulkanVariant) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(1, 1, 0, 0)));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(1, 1, 0, 0))).add_physical_device({});
DebugUtilsLogger log;
InstWrapper inst{env.vulkan_functions};
TEST(LayerManifest, ImplicitNonVulkanVariant) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0)));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0))).add_physical_device({});
const char* implicit_layer_name = "ImplicitTestLayer";
env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(LayerManifest, ExplicitNonVulkanVariant) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0)));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0))).add_physical_device({});
const char* explicit_layer_name = "ExplicitTestLayer";
env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
TEST(DriverManifest, UnknownManifestVersion) {
FrameworkEnvironment env{};
env.add_icd(
- TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_file_format_version({3, 2, 1})));
- env.get_test_icd().physical_devices.push_back({});
+ TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_file_format_version({3, 2, 1})))
+ .add_physical_device({});
DebugUtilsLogger log;
InstWrapper inst{env.vulkan_functions};
TEST(DriverManifest, LargeUnknownManifestVersion) {
FrameworkEnvironment env{};
env.add_icd(TestICDDetails(
- ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_file_format_version({100, 222, 111})));
- env.get_test_icd().physical_devices.push_back({});
+ ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_file_format_version({100, 222, 111})))
+ .add_physical_device({});
DebugUtilsLogger log;
InstWrapper inst{env.vulkan_functions};
TEST(LayerManifest, UnknownManifestVersion) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "ImplicitTestLayer";
env.add_implicit_layer(ManifestLayer{}
TEST(LayerManifest, LargeUnknownManifestVersion) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
- env.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
const char* implicit_layer_name = "ImplicitTestLayer";
env.add_implicit_layer(ManifestLayer{}
for (auto const& driver : direct_drivers) {
auto& direct_driver_icd = env.add_icd(driver.icd_details);
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
- direct_driver_icd.get_test_icd().physical_devices.at(0).properties.driverVersion = driver.driver_version;
+ direct_driver_icd.physical_devices.push_back({});
+ direct_driver_icd.physical_devices.at(0).properties.driverVersion = driver.driver_version;
VkDirectDriverLoadingInfoLUNARG ddl_info{};
ddl_info.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
- ddl_info.pfnGetInstanceProcAddr = direct_driver_icd.icd_library.get_symbol("vk_icdGetInstanceProcAddr");
+ ddl_info.pfnGetInstanceProcAddr = env.icds.back().icd_library.get_symbol("vk_icdGetInstanceProcAddr");
ddl_infos.push_back(ddl_info);
if (driver.expect_to_find) {
expected_driver_count++;
for (auto const& driver : normal_drivers) {
auto& direct_driver_icd = env.add_icd(driver.icd_details);
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
- direct_driver_icd.get_test_icd().physical_devices.at(0).properties.driverVersion = driver.driver_version;
+ direct_driver_icd.physical_devices.push_back({});
+ direct_driver_icd.physical_devices.at(0).properties.driverVersion = driver.driver_version;
if (!exclusive && driver.expect_to_find) {
expected_driver_count++;
}
FrameworkEnvironment env{};
auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
+ direct_driver_icd.physical_devices.push_back({});
VkDirectDriverLoadingInfoLUNARG ddl_info{};
ddl_info.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
- ddl_info.pfnGetInstanceProcAddr = direct_driver_icd.icd_library.get_symbol("vk_icdGetInstanceProcAddr");
+ ddl_info.pfnGetInstanceProcAddr = env.icds.back().icd_library.get_symbol("vk_icdGetInstanceProcAddr");
VkDirectDriverLoadingListLUNARG ddl_list{};
ddl_list.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
TEST(DirectDriverLoading, DriverListNotInPnextChain) {
FrameworkEnvironment env{};
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none)).add_physical_device({});
DebugUtilsLogger log;
InstWrapper inst{env.vulkan_functions};
TEST(DirectDriverLoading, DriverListHasNullDriverPointer) {
FrameworkEnvironment env{};
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none)).add_physical_device({});
VkDirectDriverLoadingListLUNARG ddl_list{};
ddl_list.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
TEST(DirectDriverLoading, DriverListHasZeroInfoCount) {
FrameworkEnvironment env{};
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none)).add_physical_device({});
VkDirectDriverLoadingInfoLUNARG ddl_info{};
ddl_info.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
- ddl_info.pfnGetInstanceProcAddr = direct_driver_icd.icd_library.get_symbol("vk_icdGetInstanceProcAddr");
+ ddl_info.pfnGetInstanceProcAddr = env.icds.back().icd_library.get_symbol("vk_icdGetInstanceProcAddr");
VkDirectDriverLoadingListLUNARG ddl_list{};
ddl_list.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
TEST(DirectDriverLoading, DriverInfoMissingGetInstanceProcAddr) {
FrameworkEnvironment env{};
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none)).add_physical_device({});
std::array<VkDirectDriverLoadingInfoLUNARG, 2> ddl_infos{};
ddl_infos[0].sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
TEST(DirectDriverLoading, DriverDoesNotExportNegotiateFunction) {
FrameworkEnvironment env{};
- auto& direct_driver_icd = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none));
- direct_driver_icd.get_test_icd().physical_devices.push_back({});
- direct_driver_icd.get_test_icd()
- .set_exposes_vk_icdNegotiateLoaderICDInterfaceVersion(false)
- .set_exposes_vkCreateInstance(false)
- .set_exposes_vkEnumerateInstanceExtensionProperties(false);
+ auto& direct_driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_7).set_discovery_type(ManifestDiscoveryType::none))
+ .add_physical_device({})
+ .set_exposes_vk_icdNegotiateLoaderICDInterfaceVersion(false)
+ .set_exposes_vkCreateInstance(false)
+ .set_exposes_vkEnumerateInstanceExtensionProperties(false);
VkDirectDriverLoadingInfoLUNARG ddl_info{};
ddl_info.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
- ddl_info.pfnGetInstanceProcAddr = direct_driver_icd.icd_library.get_symbol("vk_icdGetInstanceProcAddr");
+ ddl_info.pfnGetInstanceProcAddr = env.icds.back().icd_library.get_symbol("vk_icdGetInstanceProcAddr");
VkDirectDriverLoadingListLUNARG ddl_list{};
ddl_list.sType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
}
// Allow the negotiate function to be found, now it should fail to find instance creation function
- direct_driver_icd.get_test_icd().set_exposes_vk_icdNegotiateLoaderICDInterfaceVersion(true);
- direct_driver_icd.get_test_icd().set_max_icd_interface_version(4);
+ direct_driver.set_exposes_vk_icdNegotiateLoaderICDInterfaceVersion(true);
+ direct_driver.set_max_icd_interface_version(4);
{
DebugUtilsLogger log;
"which is incompatible with the Loader Driver Interface version that supports the VK_LUNARG_direct_driver_loading "
"extension, skipping."));
}
- direct_driver_icd.get_test_icd().set_max_icd_interface_version(7);
+ direct_driver.set_max_icd_interface_version(7);
{
DebugUtilsLogger log;
}
// Allow the instance creation function to be found, now it should fail to find EnumInstExtProps
- direct_driver_icd.get_test_icd().set_exposes_vkCreateInstance(true);
+ direct_driver.set_exposes_vkCreateInstance(true);
{
DebugUtilsLogger log;
TEST(WsiTests, ForgetEnableSurfaceExtensions) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
-
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices.back().add_extension("VK_KHR_swapchain");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .setup_WSI()
+ .add_physical_device(PhysicalDevice{}.add_extension("VK_KHR_swapchain").finish());
InstWrapper inst{env.vulkan_functions};
inst.create_info.add_extension("VK_KHR_surface");
TEST(WsiTests, SwapchainFunctional) {
FrameworkEnvironment env{};
- env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
- auto& driver = env.get_test_icd();
- driver.setup_WSI();
-
- driver.physical_devices.emplace_back("physical_device_0");
- driver.physical_devices.back().add_extension("VK_KHR_swapchain");
+ env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
+ .setup_WSI()
+ .add_physical_device(PhysicalDevice{}.add_extension("VK_KHR_swapchain").finish());
InstWrapper inst{env.vulkan_functions};
inst.create_info.setup_WSI();
projects / platform / upstream / Vulkan-Loader.git / commitdiff