1/* 2 * Copyright (c) 2021-2023 The Khronos Group Inc. 3 * Copyright (c) 2021-2023 Valve Corporation 4 * Copyright (c) 2021-2023 LunarG, Inc. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and/or associated documentation files (the "Materials"), to 8 * deal in the Materials without restriction, including without limitation the 9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 * sell copies of the Materials, and to permit persons to whom the Materials are 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice(s) and this permission notice shall be included in 14 * all copies or substantial portions of the Materials. 15 * 16 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 * 20 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 21 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 22 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE 23 * USE OR OTHER DEALINGS IN THE MATERIALS. 24 * 25 * Author: Charles Giessen <charles@lunarg.com> 26 */ 27 28#include "test_environment.h" 29 30void CheckLogForLayerString(FrameworkEnvironment& env, const char* implicit_layer_name, bool check_for_enable) { 31 { 32 InstWrapper inst{env.vulkan_functions}; 33 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 34 inst.CheckCreate(VK_SUCCESS); 35 if (check_for_enable) { 36 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + implicit_layer_name)); 37 } else { 38 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + implicit_layer_name)); 39 } 40 } 41 env.debug_log.clear(); 42} 43 44const char* lunarg_meta_layer_name = "VK_LAYER_LUNARG_override"; 45 46TEST(ImplicitLayers, WithEnableAndDisableEnvVar) { 47 FrameworkEnvironment env; 48 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 49 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 50 51 EnvVarWrapper enable_env_var{"ENABLE_ME"}; 52 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 53 54 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 55 .set_name(implicit_layer_name) 56 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 57 .set_disable_environment(disable_env_var.get()) 58 .set_enable_environment(enable_env_var.get())), 59 "implicit_test_layer.json"); 60 61 auto layers = env.GetLayerProperties(1); 62 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 63 64 // didn't set enable env-var, layer should not load 65 CheckLogForLayerString(env, implicit_layer_name, false); 66 67 // set enable env-var to 0, no layer should be found 68 enable_env_var.set_new_value("0"); 69 CheckLogForLayerString(env, implicit_layer_name, false); 70 71 // set enable env-var, layer should load 72 enable_env_var.set_new_value("1"); 73 CheckLogForLayerString(env, implicit_layer_name, true); 74 75 // remove enable env var, so we can check what happens when only disable is present 76 enable_env_var.remove_value(); 77 78 // set disable env-var to 0, layer should not load 79 disable_env_var.set_new_value("0"); 80 CheckLogForLayerString(env, implicit_layer_name, false); 81 82 // set disable env-var to 1, layer should not load 83 disable_env_var.set_new_value("1"); 84 CheckLogForLayerString(env, implicit_layer_name, false); 85 86 // set both enable and disable env-var, layer should not load 87 enable_env_var.set_new_value("1"); 88 disable_env_var.set_new_value("1"); 89 CheckLogForLayerString(env, implicit_layer_name, false); 90} 91 92TEST(ImplicitLayers, OnlyDisableEnvVar) { 93 FrameworkEnvironment env; 94 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 95 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 96 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 97 98 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 99 .set_name(implicit_layer_name) 100 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 101 .set_disable_environment(disable_env_var.get())), 102 "implicit_test_layer.json"); 103 104 auto layers = env.GetLayerProperties(1); 105 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 106 107 // don't set disable env-var, layer should load 108 CheckLogForLayerString(env, implicit_layer_name, true); 109 110 // set disable env-var to 0, layer should load 111 disable_env_var.set_new_value("0"); 112 CheckLogForLayerString(env, implicit_layer_name, false); 113 114 // set disable env-var to 1, layer should not load 115 disable_env_var.set_new_value("1"); 116 CheckLogForLayerString(env, implicit_layer_name, false); 117 118 { 119 InstWrapper inst{env.vulkan_functions}; 120 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 121 inst.create_info.add_layer(implicit_layer_name); 122 inst.CheckCreate(VK_SUCCESS); 123 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + implicit_layer_name)); 124 } 125} 126 127TEST(ImplicitLayers, PreInstanceEnumInstLayerProps) { 128 FrameworkEnvironment env; 129 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 130 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 131 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 132 133 env.add_implicit_layer( 134 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 135 ManifestLayer::LayerDescription{} 136 .set_name(implicit_layer_name) 137 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 138 .set_disable_environment(disable_env_var.get()) 139 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 140 .set_vk_func("vkEnumerateInstanceLayerProperties") 141 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))), 142 "implicit_test_layer.json"); 143 144 uint32_t layer_props = 43; 145 auto& layer = env.get_test_layer(0); 146 layer.set_reported_layer_props(layer_props); 147 148 uint32_t count = 0; 149 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr)); 150 ASSERT_EQ(count, layer_props); 151 152 // set disable env-var to 1, layer should not load 153 disable_env_var.set_new_value("1"); 154 155 count = 0; 156 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr)); 157 ASSERT_NE(count, 0U); 158 ASSERT_NE(count, layer_props); 159} 160 161TEST(ImplicitLayers, PreInstanceEnumInstExtProps) { 162 FrameworkEnvironment env; 163 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 164 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 165 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 166 167 env.add_implicit_layer( 168 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 169 ManifestLayer::LayerDescription{} 170 .set_name(implicit_layer_name) 171 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 172 .set_disable_environment(disable_env_var.get()) 173 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 174 .set_vk_func("vkEnumerateInstanceExtensionProperties") 175 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))), 176 "implicit_test_layer.json"); 177 178 uint32_t ext_props = 52; 179 auto& layer = env.get_test_layer(0); 180 layer.set_reported_extension_props(ext_props); 181 182 uint32_t count = 0; 183 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr)); 184 ASSERT_EQ(count, ext_props); 185 186 // set disable env-var to 1, layer should not load 187 disable_env_var.set_new_value("1"); 188 189 count = 0; 190 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr)); 191 ASSERT_NE(count, 0U); 192 ASSERT_NE(count, ext_props); 193} 194 195TEST(ImplicitLayers, PreInstanceVersion) { 196 FrameworkEnvironment env; 197 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)) 198 .add_physical_device({}) 199 .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 2, 3)); 200 201 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 202 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 203 204 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 205 ManifestLayer::LayerDescription{} 206 .set_name(implicit_layer_name) 207 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 208 .set_api_version(VK_MAKE_API_VERSION(0, 1, 2, 3)) 209 .set_disable_environment(disable_env_var.get()) 210 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 211 .set_vk_func("vkEnumerateInstanceVersion") 212 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))), 213 "implicit_test_layer.json"); 214 215 uint32_t layer_version = VK_MAKE_API_VERSION(1, 2, 3, 4); 216 auto& layer = env.get_test_layer(0); 217 layer.set_reported_instance_version(layer_version); 218 219 uint32_t version = 0; 220 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version)); 221 ASSERT_EQ(version, layer_version); 222 223 // set disable env-var to 1, layer should not load 224 disable_env_var.set_new_value("1"); 225 226 version = 0; 227 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version)); 228 ASSERT_NE(version, 0U); 229 ASSERT_NE(version, layer_version); 230} 231 232// Run with a pre-Negotiate function version of the layer so that it has to query vkCreateInstance using the 233// renamed vkGetInstanceProcAddr function which returns one that intentionally fails. Then disable the 234// layer and verify it works. The non-override version of vkCreateInstance in the layer also works (and is 235// tested through behavior above). 236TEST(ImplicitLayers, OverrideGetInstanceProcAddr) { 237 FrameworkEnvironment env; 238 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 239 240 const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer"; 241 EnvVarWrapper disable_env_var{"DISABLE_ME"}; 242 243 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 0, 0}).add_layer( 244 ManifestLayer::LayerDescription{} 245 .set_name(implicit_layer_name) 246 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_1) 247 .set_disable_environment(disable_env_var.get()) 248 .add_function(ManifestLayer::LayerDescription::FunctionOverride{} 249 .set_vk_func("vkGetInstanceProcAddr") 250 .set_override_name("test_override_vkGetInstanceProcAddr"))), 251 "implicit_test_layer.json"); 252 253 { 254 InstWrapper inst1{env.vulkan_functions}; 255 inst1.CheckCreate(VK_ERROR_INVALID_SHADER_NV); 256 } 257 258 { 259 // set disable env-var to 1, layer should not load 260 disable_env_var.set_new_value("1"); 261 InstWrapper inst2{env.vulkan_functions}; 262 inst2.CheckCreate(); 263 } 264} 265 266// Force enable with filter env var 267TEST(ImplicitLayers, EnableWithFilter) { 268 FrameworkEnvironment env; 269 270 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)) 271 .add_physical_device({}) 272 .set_icd_api_version(VK_API_VERSION_1_2); 273 274 const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 275 const char* implicit_json_name_1 = "First_layer.json"; 276 const char* disable_layer_name_1 = "DISABLE_FIRST"; 277 const char* enable_layer_name_1 = "ENABLE_FIRST"; 278 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 279 .set_name(implicit_layer_name_1) 280 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 281 .set_enable_environment(enable_layer_name_1) 282 .set_disable_environment(disable_layer_name_1) 283 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 284 implicit_json_name_1); 285 286 const char* implicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 287 const char* implicit_json_name_2 = "Second_layer.json"; 288 const char* disable_layer_name_2 = "DISABLE_SECOND"; 289 const char* enable_layer_name_2 = "ENABLE_SECOND"; 290 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 291 .set_name(implicit_layer_name_2) 292 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 293 .set_enable_environment(enable_layer_name_2) 294 .set_disable_environment(disable_layer_name_2) 295 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 296 implicit_json_name_2); 297 298 const char* implicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer"; 299 const char* implicit_json_name_3 = "Second_test_layer.json"; 300 const char* disable_layer_name_3 = "DISABLE_THIRD"; 301 const char* enable_layer_name_3 = "ENABLE_THIRD"; 302 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 303 .set_name(implicit_layer_name_3) 304 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 305 .set_enable_environment(enable_layer_name_3) 306 .set_disable_environment(disable_layer_name_3) 307 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 308 implicit_json_name_3); 309 310 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"}; 311 EnvVarWrapper layer_1_enable_env_var{enable_layer_name_1}; 312 313 // First, test an instance/device without the layer forced on. 314 InstWrapper inst1{env.vulkan_functions}; 315 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 316 inst1.CheckCreate(); 317 318 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 319 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 320 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 321 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 322 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 323 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 324 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 325 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 326 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 327 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 328 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 329 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 330 331 // Now force on one layer with its full name 332 // ------------------------------------------ 333 env.debug_log.clear(); 334 layers_enable_env_var.set_new_value(implicit_layer_name_1); 335 336 InstWrapper inst2{env.vulkan_functions}; 337 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 338 inst2.CheckCreate(); 339 340 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 341 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 342 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 343 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 344 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 345 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 346 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 347 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 348 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 349 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 350 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 351 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 352 353 // Match prefix 354 // ------------------------------------------ 355 env.debug_log.clear(); 356 layers_enable_env_var.set_new_value("VK_LAYER_LUNARG_*"); 357 358 InstWrapper inst3{env.vulkan_functions}; 359 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 360 inst3.CheckCreate(); 361 362 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 363 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 364 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 365 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 366 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 367 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 368 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 369 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 370 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 371 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 372 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 373 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 374 375 // Match suffix 376 // ------------------------------------------ 377 env.debug_log.clear(); 378 layers_enable_env_var.set_new_value("*Second_layer"); 379 380 InstWrapper inst4{env.vulkan_functions}; 381 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 382 inst4.CheckCreate(); 383 384 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 385 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 386 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 387 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 388 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 389 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 390 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 391 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 392 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 393 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 394 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 395 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 396 397 // Match substring 398 // ------------------------------------------ 399 env.debug_log.clear(); 400 layers_enable_env_var.set_new_value("*Second*"); 401 402 InstWrapper inst5{env.vulkan_functions}; 403 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 404 inst5.CheckCreate(); 405 406 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 407 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 408 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 409 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 410 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 411 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 412 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 413 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 414 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 415 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 416 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 417 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 418 419 // Match all with star '*' 420 // ------------------------------------------ 421 env.debug_log.clear(); 422 layers_enable_env_var.set_new_value("*"); 423 424 InstWrapper inst6{env.vulkan_functions}; 425 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 426 inst6.CheckCreate(); 427 428 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 429 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 430 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 431 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 432 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 433 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 434 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 435 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 436 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 437 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 438 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 439 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 440 441 // Match all with special name 442 // ------------------------------------------ 443 env.debug_log.clear(); 444 layers_enable_env_var.set_new_value("~all~"); 445 446 InstWrapper inst7{env.vulkan_functions}; 447 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log); 448 inst7.CheckCreate(); 449 450 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 451 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 452 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 453 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 454 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 455 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 456 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 457 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 458 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 459 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 460 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 461 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 462 463 // Match substring, but enable the other layer manually 464 // ------------------------------------------ 465 env.debug_log.clear(); 466 layer_1_enable_env_var.set_new_value("1"); 467 layers_enable_env_var.set_new_value("*Second*"); 468 469 InstWrapper inst8{env.vulkan_functions}; 470 FillDebugUtilsCreateDetails(inst8.create_info, env.debug_log); 471 inst8.CheckCreate(); 472 473 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 474 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 475 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 476 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 477 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 478 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 479 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 480 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 481 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 482 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 483 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 484 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 485} 486 487// Force disabled with new filter env var 488TEST(ImplicitLayers, DisableWithFilter) { 489 FrameworkEnvironment env; 490 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 491 .set_icd_api_version(VK_API_VERSION_1_2); 492 493 const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 494 const char* implicit_json_name_1 = "First_layer.json"; 495 const char* disable_layer_name_1 = "DISABLE_FIRST"; 496 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 497 .set_name(implicit_layer_name_1) 498 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 499 .set_disable_environment(disable_layer_name_1) 500 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 501 implicit_json_name_1); 502 503 const char* implicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 504 const char* implicit_json_name_2 = "Second_layer.json"; 505 const char* disable_layer_name_2 = "DISABLE_SECOND"; 506 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 507 .set_name(implicit_layer_name_2) 508 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 509 .set_disable_environment(disable_layer_name_2) 510 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 511 implicit_json_name_2); 512 513 const char* implicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer"; 514 const char* implicit_json_name_3 = "Second_test_layer.json"; 515 const char* disable_layer_name_3 = "DISABLE_THIRD"; 516 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 517 .set_name(implicit_layer_name_3) 518 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 519 .set_disable_environment(disable_layer_name_3) 520 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 521 implicit_json_name_3); 522 523 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 524 525 // First, test an instance/device 526 InstWrapper inst1{env.vulkan_functions}; 527 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 528 inst1.CheckCreate(); 529 530 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 531 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 532 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 533 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 534 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 535 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 536 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 537 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 538 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 539 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 540 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 541 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 542 543 // Now force off one layer with its full name 544 // ------------------------------------------ 545 env.debug_log.clear(); 546 layers_disable_env_var.set_new_value(implicit_layer_name_1); 547 548 InstWrapper inst2{env.vulkan_functions}; 549 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 550 inst2.CheckCreate(); 551 552 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 553 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 554 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 555 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 556 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 557 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 558 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 559 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 560 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 561 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 562 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 563 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 564 565 // Match prefix 566 // ------------------------------------------ 567 env.debug_log.clear(); 568 layers_disable_env_var.set_new_value("VK_LAYER_LUNARG_*"); 569 570 InstWrapper inst3{env.vulkan_functions}; 571 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 572 inst3.CheckCreate(); 573 574 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 575 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 576 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 577 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 578 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 579 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 580 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 581 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 582 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 583 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 584 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 585 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 586 587 // Match suffix 588 // ------------------------------------------ 589 env.debug_log.clear(); 590 layers_disable_env_var.set_new_value("*Second_layer"); 591 592 InstWrapper inst4{env.vulkan_functions}; 593 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 594 inst4.CheckCreate(); 595 596 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 597 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 598 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 599 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 600 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 601 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 602 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 603 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 604 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 605 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 606 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 607 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 608 609 // Match substring 610 // ------------------------------------------ 611 env.debug_log.clear(); 612 layers_disable_env_var.set_new_value("*Second*"); 613 614 InstWrapper inst5{env.vulkan_functions}; 615 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 616 inst5.CheckCreate(); 617 618 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 619 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 620 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 621 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 622 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 623 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 624 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 625 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 626 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 627 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 628 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 629 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 630 631 // Match all with star '*' 632 // ------------------------------------------ 633 env.debug_log.clear(); 634 layers_disable_env_var.set_new_value("*"); 635 636 InstWrapper inst6{env.vulkan_functions}; 637 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 638 inst6.CheckCreate(); 639 640 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 641 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 642 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 643 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 644 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 645 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 646 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 647 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 648 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 649 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 650 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 651 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 652 653 // Match all with special name 654 // ------------------------------------------ 655 env.debug_log.clear(); 656 layers_disable_env_var.set_new_value("~all~"); 657 658 InstWrapper inst7{env.vulkan_functions}; 659 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log); 660 inst7.CheckCreate(); 661 662 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 663 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 664 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 665 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 666 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 667 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 668 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 669 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 670 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 671 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 672 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 673 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 674} 675 676// Force disabled with new filter env var 677TEST(ImplicitLayers, DisableWithFilterWhenLayersEnableEnvVarIsActive) { 678 FrameworkEnvironment env; 679 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 680 .set_icd_api_version(VK_API_VERSION_1_2); 681 682 const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 683 const char* implicit_json_name_1 = "First_layer.json"; 684 const char* disable_layer_name_1 = "DISABLE_FIRST"; 685 const char* enable_layer_name_1 = "ENABLE_FIRST"; 686 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 687 .set_name(implicit_layer_name_1) 688 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 689 .set_disable_environment(disable_layer_name_1) 690 .set_enable_environment(enable_layer_name_1) 691 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 692 implicit_json_name_1); 693 694 const char* implicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 695 const char* implicit_json_name_2 = "Second_layer.json"; 696 const char* disable_layer_name_2 = "DISABLE_SECOND"; 697 const char* enable_layer_name_2 = "ENABLE_SECOND"; 698 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 699 .set_name(implicit_layer_name_2) 700 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 701 .set_disable_environment(disable_layer_name_2) 702 .set_enable_environment(enable_layer_name_2) 703 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 704 implicit_json_name_2); 705 706 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 707 EnvVarWrapper layer_1_enable_env_var{enable_layer_name_1}; 708 EnvVarWrapper layer_2_enable_env_var{enable_layer_name_2}; 709 710 // First, test an instance/device 711 InstWrapper inst1{env.vulkan_functions}; 712 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 713 inst1.CheckCreate(); 714 715 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 716 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 717 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 718 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 719 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 720 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 721 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 722 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 723 724 // Set the layers enable env-var 725 // ------------------------------------------ 726 env.debug_log.clear(); 727 layer_1_enable_env_var.set_new_value("1"); 728 layer_2_enable_env_var.set_new_value("1"); 729 730 InstWrapper inst2{env.vulkan_functions}; 731 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 732 inst2.CheckCreate(); 733 734 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 735 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 736 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 737 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 738 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 739 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 740 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 741 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 742 743 // Now force off one layer with its full name 744 // ------------------------------------------ 745 env.debug_log.clear(); 746 layers_disable_env_var.set_new_value(implicit_layer_name_1); 747 748 InstWrapper inst3{env.vulkan_functions}; 749 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 750 inst3.CheckCreate(); 751 752 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 753 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 754 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 755 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 756 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 757 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 758 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 759 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 760 761 // Now force off both layers 762 // ------------------------------------------ 763 env.debug_log.clear(); 764 layers_disable_env_var.set_new_value("~implicit~"); 765 766 InstWrapper inst4{env.vulkan_functions}; 767 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 768 inst4.CheckCreate(); 769 770 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 771 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 772 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 773 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 774 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 775 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 776 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 777 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 778} 779 780// Test interaction between both the enable and disable filter environment variables. The enable should always 781// override the disable. 782TEST(ImplicitLayers, EnableAndDisableWithFilter) { 783 FrameworkEnvironment env; 784 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 785 .set_icd_api_version(VK_API_VERSION_1_2); 786 787 const char* implicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 788 const char* implicit_json_name_1 = "First_layer.json"; 789 const char* disable_layer_name_1 = "DISABLE_FIRST"; 790 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 791 .set_name(implicit_layer_name_1) 792 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 793 .set_disable_environment(disable_layer_name_1) 794 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 795 implicit_json_name_1); 796 797 const char* implicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 798 const char* implicit_json_name_2 = "Second_layer.json"; 799 const char* disable_layer_name_2 = "DISABLE_SECOND"; 800 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 801 .set_name(implicit_layer_name_2) 802 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 803 .set_disable_environment(disable_layer_name_2) 804 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 805 implicit_json_name_2); 806 807 const char* implicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer"; 808 const char* implicit_json_name_3 = "Second_test_layer.json"; 809 const char* disable_layer_name_3 = "DISABLE_THIRD"; 810 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 811 .set_name(implicit_layer_name_3) 812 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 813 .set_disable_environment(disable_layer_name_3) 814 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 815 implicit_json_name_3); 816 817 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 818 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"}; 819 820 // Disable 2 but enable 1 821 // ------------------------------------------ 822 env.debug_log.clear(); 823 layers_disable_env_var.set_new_value("*Second*"); 824 layers_enable_env_var.set_new_value("*test_layer"); 825 826 InstWrapper inst1{env.vulkan_functions}; 827 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 828 inst1.CheckCreate(); 829 830 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 831 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 832 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 833 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 834 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 835 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 836 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 837 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 838 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 839 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 840 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 841 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 842 843 // Disable all but enable 2 844 // ------------------------------------------ 845 env.debug_log.clear(); 846 layers_disable_env_var.set_new_value("*"); 847 layers_enable_env_var.set_new_value("*Second*"); 848 849 InstWrapper inst2{env.vulkan_functions}; 850 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 851 inst2.CheckCreate(); 852 853 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 854 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 855 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 856 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 857 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 858 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 859 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 860 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 861 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 862 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 863 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 864 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 865 866 // Disable all but enable 2 867 // ------------------------------------------ 868 env.debug_log.clear(); 869 layers_disable_env_var.set_new_value("~all~"); 870 layers_enable_env_var.set_new_value("*Second*"); 871 872 InstWrapper inst3{env.vulkan_functions}; 873 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 874 inst3.CheckCreate(); 875 876 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 877 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 878 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 879 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 880 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 881 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 882 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 883 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 884 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 885 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 886 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 887 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 888 889 // Disable implicit but enable 2 890 // ------------------------------------------ 891 env.debug_log.clear(); 892 layers_disable_env_var.set_new_value("~implicit~"); 893 layers_enable_env_var.set_new_value("*Second*"); 894 895 InstWrapper inst4{env.vulkan_functions}; 896 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 897 inst4.CheckCreate(); 898 899 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 900 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 901 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 902 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 903 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 904 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 905 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 906 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 907 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 908 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 909 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 910 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 911 912 // Disable explicit but enable 2 (should still be everything) 913 // ------------------------------------------ 914 env.debug_log.clear(); 915 layers_disable_env_var.set_new_value("~explicit~"); 916 layers_enable_env_var.set_new_value("*Second*"); 917 918 InstWrapper inst5{env.vulkan_functions}; 919 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 920 inst5.CheckCreate(); 921 922 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 923 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 924 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 925 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 926 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 927 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 928 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 929 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 930 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 931 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 932 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 933 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 934 935 // Disable implicit but enable all 936 // ------------------------------------------ 937 env.debug_log.clear(); 938 layers_disable_env_var.set_new_value("~implicit~"); 939 layers_enable_env_var.set_new_value("*"); 940 941 InstWrapper inst6{env.vulkan_functions}; 942 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 943 inst6.CheckCreate(); 944 945 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_1)); 946 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_1)); 947 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "forced enabled due to env var")); 948 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_1, "disabled because name matches filter of env var")); 949 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_2)); 950 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_2)); 951 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "forced enabled due to env var")); 952 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_2, "disabled because name matches filter of env var")); 953 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", implicit_json_name_3)); 954 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", implicit_layer_name_3)); 955 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "forced enabled due to env var")); 956 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(implicit_layer_name_3, "disabled because name matches filter of env var")); 957} 958 959// Add 2 implicit layers with the same layer name and expect only one to be loaded. 960// Expect the second layer to be found first, because it'll be in a path that is searched first. 961TEST(ImplicitLayers, DuplicateLayers) { 962 FrameworkEnvironment env; 963 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 964 965 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 966 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1"; 967 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 968 .set_name(same_layer_name_1) 969 .set_description("actually_layer_1") 970 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 971 .set_disable_environment("if_you_can")), 972 "regular_layer_1.json")); 973 auto& layer1 = env.get_test_layer(0); 974 layer1.set_description("actually_layer_1"); 975 layer1.set_make_spurious_log_in_create_instance("actually_layer_1"); 976 977 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 978 .set_name(same_layer_name_1) 979 .set_description("actually_layer_2") 980 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 981 .set_disable_environment("if_you_can")), 982 "regular_layer_1.json") 983 // use override folder as just a folder and manually add it to the implicit layer search paths 984 .set_discovery_type(ManifestDiscoveryType::override_folder)); 985 auto& layer2 = env.get_test_layer(1); 986 layer2.set_description("actually_layer_2"); 987 layer2.set_make_spurious_log_in_create_instance("actually_layer_2"); 988#if defined(WIN32) 989 env.platform_shim->add_manifest(ManifestCategory::implicit_layer, env.get_folder(ManifestLocation::override_layer).location()); 990#elif COMMON_UNIX_PLATFORMS 991 env.platform_shim->redirect_path(fs::path(USER_LOCAL_SHARE_DIR "/vulkan/implicit_layer.d"), 992 env.get_folder(ManifestLocation::override_layer).location()); 993#endif 994 995 auto layer_props = env.GetLayerProperties(2); 996 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName)); 997 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName)); 998 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 999 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 1000 1001 InstWrapper inst{env.vulkan_functions}; 1002 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1003 inst.CheckCreate(); 1004 1005 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 1006 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 1007 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 1008 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 1009 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 1010} 1011 1012// Meta layer which contains component layers that do not exist. 1013TEST(MetaLayers, InvalidComponentLayer) { 1014 FrameworkEnvironment env; 1015 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 1016 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1017 const char* invalid_layer_name_1 = "VK_LAYER_InvalidLayer1"; 1018 const char* invalid_layer_name_2 = "VK_LAYER_InvalidLayer2"; 1019 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1020 ManifestLayer::LayerDescription{} 1021 .set_name(meta_layer_name) 1022 .add_component_layers({invalid_layer_name_1, invalid_layer_name_2}) 1023 .set_disable_environment("NotGonnaWork") 1024 .add_instance_extension({"NeverGonnaGiveYouUp"}) 1025 .add_device_extension({"NeverGonnaLetYouDown"})), 1026 "meta_test_layer.json"); 1027 1028 const char* regular_layer_name = "TestLayer"; 1029 env.add_explicit_layer( 1030 ManifestLayer{}.add_layer( 1031 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1032 "regular_test_layer.json"); 1033 1034 // should find 1, the 'regular' layer 1035 auto layer_props = env.GetLayerProperties(1); 1036 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name)); 1037 1038 auto extensions = env.GetInstanceExtensions(4); 1039 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 1040 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 1041 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 1042 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 1043 1044 InstWrapper inst{env.vulkan_functions}; 1045 inst.create_info.add_layer(meta_layer_name); 1046 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1047 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 1048 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name + 1049 " can't find component layer " + invalid_layer_name_1 + " at index 0. Skipping this layer.")); 1050} 1051 1052// Meta layer that is an explicit layer 1053TEST(MetaLayers, ExplicitMetaLayer) { 1054 FrameworkEnvironment env; 1055 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1056 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1057 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1058 env.add_explicit_layer( 1059 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1060 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})), 1061 "meta_test_layer.json"); 1062 1063 env.add_explicit_layer( 1064 ManifestLayer{}.add_layer( 1065 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1066 "regular_test_layer.json"); 1067 1068 { // global functions 1069 // should find 1, the 'regular' layer 1070 auto layer_props = env.GetLayerProperties(2); 1071 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props)); 1072 1073 auto extensions = env.GetInstanceExtensions(4); 1074 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 1075 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 1076 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 1077 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 1078 } 1079 { // don't enable the layer, shouldn't find any layers when calling vkEnumerateDeviceLayerProperties 1080 InstWrapper inst{env.vulkan_functions}; 1081 inst.CheckCreate(VK_SUCCESS); 1082 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 1083 } 1084 { 1085 InstWrapper inst{env.vulkan_functions}; 1086 inst.create_info.add_layer(meta_layer_name); 1087 inst.CheckCreate(VK_SUCCESS); 1088 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1089 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props)); 1090 } 1091} 1092 1093// Meta layer which adds itself in its list of component layers 1094TEST(MetaLayers, MetaLayerNameInComponentLayers) { 1095 FrameworkEnvironment env; 1096 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 1097 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1098 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1099 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1100 ManifestLayer::LayerDescription{} 1101 .set_name(meta_layer_name) 1102 .add_component_layers({meta_layer_name, regular_layer_name}) 1103 .set_disable_environment("NotGonnaWork") 1104 .add_instance_extension({"NeverGonnaGiveYouUp"}) 1105 .add_device_extension({"NeverGonnaLetYouDown"})), 1106 "meta_test_layer.json"); 1107 1108 env.add_explicit_layer( 1109 ManifestLayer{}.add_layer( 1110 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1111 "regular_test_layer.json"); 1112 1113 // should find 1, the 'regular' layer 1114 auto layer_props = env.GetLayerProperties(1); 1115 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name)); 1116 1117 auto extensions = env.GetInstanceExtensions(4); 1118 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 1119 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 1120 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 1121 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 1122 1123 InstWrapper inst{env.vulkan_functions}; 1124 inst.create_info.add_layer(meta_layer_name); 1125 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1126 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 1127 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name + 1128 " lists itself in its component layer " + "list at index 0. Skipping this layer.")); 1129} 1130 1131// Meta layer which adds another meta layer as a component layer 1132TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) { 1133 FrameworkEnvironment env; 1134 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); 1135 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1136 const char* meta_meta_layer_name = "VK_LAYER_MetaMetaTestLayer"; 1137 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1138 env.add_explicit_layer( 1139 ManifestLayer{}.add_layer( 1140 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1141 "regular_test_layer.json"); 1142 env.add_explicit_layer( 1143 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1144 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})), 1145 "meta_test_layer.json"); 1146 env.add_explicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1147 ManifestLayer::LayerDescription{} 1148 .set_name(meta_meta_layer_name) 1149 .add_component_layers({meta_layer_name, regular_layer_name})), 1150 "meta_meta_test_layer.json"); 1151 1152 auto layer_props = env.GetLayerProperties(3); 1153 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name, meta_meta_layer_name}, layer_props)); 1154 1155 auto extensions = env.GetInstanceExtensions(4); 1156 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 1157 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 1158 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 1159 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 1160 1161 InstWrapper inst{env.vulkan_functions}; 1162 inst.create_info.add_layer(meta_layer_name); 1163 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1164 inst.CheckCreate(); 1165 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Adding meta-layer ") + meta_meta_layer_name + 1166 " which also contains meta-layer " + meta_layer_name)); 1167} 1168 1169TEST(MetaLayers, InstanceExtensionInComponentLayer) { 1170 FrameworkEnvironment env; 1171 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1172 1173 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1174 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1175 const char* instance_ext_name = "VK_EXT_headless_surface"; 1176 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1177 .set_name(regular_layer_name) 1178 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1179 .add_instance_extension({instance_ext_name})), 1180 "regular_test_layer.json"); 1181 env.add_explicit_layer( 1182 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1183 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})), 1184 "meta_test_layer.json"); 1185 1186 auto extensions = env.GetInstanceExtensions(1, meta_layer_name); 1187 EXPECT_TRUE(string_eq(extensions[0].extensionName, instance_ext_name)); 1188} 1189 1190TEST(MetaLayers, DeviceExtensionInComponentLayer) { 1191 FrameworkEnvironment env; 1192 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1193 1194 const char* meta_layer_name = "VK_LAYER_MetaTestLayer"; 1195 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1196 const char* device_ext_name = "VK_EXT_fake_dev_ext"; 1197 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1198 .set_name(regular_layer_name) 1199 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1200 .add_device_extension({device_ext_name})), 1201 "regular_test_layer.json"); 1202 env.add_explicit_layer( 1203 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1204 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})), 1205 "meta_test_layer.json"); 1206 1207 ASSERT_NO_FATAL_FAILURE(env.GetInstanceExtensions(0, meta_layer_name)); 1208 1209 { // layer is not enabled 1210 InstWrapper inst{env.vulkan_functions}; 1211 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1212 inst.CheckCreate(); 1213 ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name + 1214 " adding device extension " + device_ext_name)); 1215 1216 auto extensions = inst.EnumerateLayerDeviceExtensions(inst.GetPhysDev(), meta_layer_name, 1); 1217 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, device_ext_name)); 1218 } 1219 { // layer is enabled 1220 InstWrapper inst{env.vulkan_functions}; 1221 inst.create_info.add_layer(meta_layer_name); 1222 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1223 inst.CheckCreate(); 1224 ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name + 1225 " adding device extension " + device_ext_name)); 1226 1227 auto extensions = inst.EnumerateLayerDeviceExtensions(inst.GetPhysDev(), meta_layer_name, 1); 1228 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, device_ext_name)); 1229 } 1230} 1231 1232// Override meta layer missing disable environment variable still enables the layer 1233TEST(OverrideMetaLayer, InvalidDisableEnvironment) { 1234 FrameworkEnvironment env; 1235 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1236 1237 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1238 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1239 .set_name(regular_layer_name) 1240 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1241 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1242 .add_device_extension({"NeverGonnaLetYouDown"})), 1243 "regular_test_layer.json"); 1244 1245 env.add_implicit_layer( 1246 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{} 1247 .set_name(lunarg_meta_layer_name) 1248 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1249 .add_component_layers({regular_layer_name})), 1250 "meta_test_layer.json"); 1251 1252 auto layer_props = env.GetLayerProperties(1); 1253 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1254 1255 InstWrapper inst{env.vulkan_functions}; 1256 inst.CheckCreate(); 1257} 1258 1259// Override meta layer whose version is less than the api version of the instance 1260TEST(OverrideMetaLayer, OlderVersionThanInstance) { 1261 FrameworkEnvironment env; 1262 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1263 1264 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1265 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1266 .set_name(regular_layer_name) 1267 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1268 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1269 .add_device_extension({"NeverGonnaLetYouDown"})), 1270 "regular_test_layer.json"); 1271 1272 env.add_implicit_layer( 1273 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{} 1274 .set_name(lunarg_meta_layer_name) 1275 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1276 .set_disable_environment("DisableMeIfYouCan") 1277 .add_component_layers({regular_layer_name})), 1278 "meta_test_layer.json"); 1279 { // global functions 1280 auto layer_props = env.GetLayerProperties(2); 1281 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1282 } 1283 { // 1.1 instance 1284 InstWrapper inst{env.vulkan_functions}; 1285 inst.create_info.api_version = VK_API_VERSION_1_1; 1286 inst.CheckCreate(); 1287 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1288 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1289 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name)); 1290 } 1291 { // 1.3 instance 1292 1293 InstWrapper inst{env.vulkan_functions}; 1294 inst.create_info.api_version = VK_API_VERSION_1_3; 1295 inst.CheckCreate(); 1296 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1297 1298 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1299 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name)); 1300 } 1301} 1302 1303TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) { 1304 FrameworkEnvironment env; 1305 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1306 1307 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1308 env.add_explicit_layer( 1309 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1310 .set_name(regular_layer_name) 1311 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1312 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 1313 "regular_test_layer.json"); 1314 1315 env.add_implicit_layer( 1316 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1317 .set_name(lunarg_meta_layer_name) 1318 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1319 .add_component_layers({regular_layer_name}) 1320 .set_disable_environment("DisableMeIfYouCan")), 1321 "meta_test_layer.json"); 1322 { // global functions 1323 auto layer_props = env.GetLayerProperties(2); 1324 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1325 } 1326 { 1327 // 1.1 instance 1328 InstWrapper inst{env.vulkan_functions}; 1329 inst.create_info.set_api_version(1, 1, 0); 1330 inst.CheckCreate(); 1331 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1332 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1333 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name)); 1334 } 1335 1336 { 1337 // 1.3 instance 1338 InstWrapper inst{env.vulkan_functions}; 1339 inst.create_info.set_api_version(1, 3, 0); 1340 inst.CheckCreate(); 1341 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1342 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1343 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name)); 1344 } 1345} 1346 1347TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) { 1348 FrameworkEnvironment env; 1349 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1350 1351 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1352 env.add_explicit_layer( 1353 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1354 .set_name(regular_layer_name) 1355 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1356 .set_api_version(VK_API_VERSION_1_2)), 1357 "regular_test_layer.json"); 1358 1359 env.add_implicit_layer( 1360 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1361 .set_name(lunarg_meta_layer_name) 1362 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1363 .add_component_layers({regular_layer_name}) 1364 .set_disable_environment("DisableMeIfYouCan")), 1365 "meta_test_layer.json"); 1366 1367 { // global functions 1368 auto layer_props = env.GetLayerProperties(2); 1369 // Expect the explicit layer to still be found 1370 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1371 } 1372 { 1373 // 1.1 instance 1374 InstWrapper inst{env.vulkan_functions}; 1375 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1376 inst.create_info.set_api_version(1, 1, 0); 1377 inst.CheckCreate(); 1378 // Newer component is allowed now 1379 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1380 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1381 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1382 } 1383 env.debug_log.clear(); 1384 1385 { 1386 // 1.3 instance 1387 InstWrapper inst{env.vulkan_functions}; 1388 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1389 inst.create_info.set_api_version(1, 3, 0); 1390 inst.CheckCreate(); 1391 // Newer component is allowed now 1392 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1393 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1394 1395 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1396 } 1397} 1398 1399TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) { 1400 FrameworkEnvironment env; 1401 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1402 1403 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1404 env.add_explicit_layer( 1405 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1406 .set_name(regular_layer_name) 1407 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1408 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 1409 "regular_test_layer.json"); 1410 1411 env.add_implicit_layer( 1412 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1413 .set_name(lunarg_meta_layer_name) 1414 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1415 .add_component_layers({regular_layer_name}) 1416 .set_disable_environment("DisableMeIfYouCan")), 1417 "meta_test_layer.json"); 1418 { // global functions 1419 auto layer_props = env.GetLayerProperties(1); 1420 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1421 } 1422 { 1423 // 1.1 instance 1424 InstWrapper inst{env.vulkan_functions}; 1425 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1426 inst.create_info.set_api_version(1, 1, 0); 1427 inst.CheckCreate(); 1428 EXPECT_TRUE( 1429 env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 has API " 1430 "version 1.0 that is lower. Skipping this layer.")); 1431 env.debug_log.clear(); 1432 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 1433 } 1434 1435 { 1436 // 1.2 instance 1437 InstWrapper inst{env.vulkan_functions}; 1438 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1439 inst.create_info.set_api_version(1, 2, 0); 1440 inst.CheckCreate(); 1441 ASSERT_TRUE( 1442 env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 has API " 1443 "version 1.0 that is lower. Skipping this layer.")); 1444 env.debug_log.clear(); 1445 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 1446 } 1447} 1448 1449TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) { 1450 FrameworkEnvironment env; 1451 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1452 1453 const char* automatic_regular_layer_name = "VK_LAYER_TestLayer_1"; 1454 const char* manual_regular_layer_name = "VK_LAYER_TestLayer_2"; 1455 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1456 .set_name(automatic_regular_layer_name) 1457 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1458 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 1459 "regular_test_layer_1.json"); 1460 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1461 .set_name(manual_regular_layer_name) 1462 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1463 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 1464 "regular_test_layer_2.json"); 1465 env.add_implicit_layer( 1466 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1467 .set_name(lunarg_meta_layer_name) 1468 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1469 .add_component_layer(automatic_regular_layer_name) 1470 .add_blacklisted_layer(manual_regular_layer_name) 1471 .set_disable_environment("DisableMeIfYouCan")), 1472 "meta_test_layer.json"); 1473 { // Check that enumerating the layers returns only the non-blacklisted layers + override layer 1474 auto layer_props = env.GetLayerProperties(2); 1475 ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1476 } 1477 { 1478 // enable the layer in the blacklist 1479 InstWrapper inst{env.vulkan_functions}; 1480 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1481 inst.create_info.add_layer(manual_regular_layer_name); 1482 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 1483 ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") + 1484 manual_regular_layer_name + 1485 " is in the blacklist inside of it. Removing that layer from current layer list.")); 1486 env.debug_log.clear(); 1487 } 1488 { // dont enable the layer in the blacklist 1489 InstWrapper inst{env.vulkan_functions}; 1490 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1491 inst.CheckCreate(); 1492 ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") + 1493 manual_regular_layer_name + 1494 " is in the blacklist inside of it. Removing that layer from current layer list.")); 1495 env.debug_log.clear(); 1496 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1497 ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1498 } 1499} 1500 1501TEST(OverrideMetaLayer, BasicOverridePaths) { 1502 FrameworkEnvironment env; 1503 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1504 1505 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1506 1507 const char* regular_layer_name = "VK_LAYER_TestLayer_1"; 1508 override_layer_folder.write_manifest("regular_test_layer.json", 1509 ManifestLayer{} 1510 .add_layer(ManifestLayer::LayerDescription{} 1511 .set_name(regular_layer_name) 1512 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1513 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1514 .get_manifest_str()); 1515 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1516 ManifestLayer::LayerDescription{} 1517 .set_name(lunarg_meta_layer_name) 1518 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1519 .add_component_layer(regular_layer_name) 1520 .set_disable_environment("DisableMeIfYouCan") 1521 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1522 "meta_test_layer.json"); 1523 1524 InstWrapper inst{env.vulkan_functions}; 1525 inst.create_info.set_api_version(1, 1, 0); 1526 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1527 inst.CheckCreate(); 1528 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1529 env.layers.clear(); 1530} 1531 1532TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) { 1533 FrameworkEnvironment env; 1534 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1535 1536 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1537 1538 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1539 env.add_explicit_layer( 1540 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1541 .set_name(regular_layer_name) 1542 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1543 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 1544 "regular_test_layer.json"); 1545 1546 const char* special_layer_name = "VK_LAYER_TestLayer_1"; 1547 override_layer_folder.write_manifest("regular_test_layer.json", 1548 ManifestLayer{} 1549 .add_layer(ManifestLayer::LayerDescription{} 1550 .set_name(special_layer_name) 1551 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1552 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1553 .get_manifest_str()); 1554 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1555 ManifestLayer::LayerDescription{} 1556 .set_name(lunarg_meta_layer_name) 1557 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1558 .add_component_layer(special_layer_name) 1559 .set_disable_environment("DisableMeIfYouCan") 1560 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1561 "meta_test_layer.json"); 1562 1563 InstWrapper inst{env.vulkan_functions}; 1564 inst.create_info.set_api_version(1, 1, 0); 1565 inst.create_info.add_layer(regular_layer_name); 1566 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1567 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 1568 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1569 env.layers.clear(); 1570} 1571 1572TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) { 1573 FrameworkEnvironment env; 1574 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1575 1576 // add explicit layer to VK_LAYER_PATH folder 1577 const char* env_var_layer_name = "VK_LAYER_env_var_set_path"; 1578 env.add_explicit_layer(TestLayerDetails{ 1579 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1580 .set_name(env_var_layer_name) 1581 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1582 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 1583 "regular_test_layer.json"} 1584 .set_discovery_type(ManifestDiscoveryType::env_var)); 1585 1586 // add layer to regular explicit layer folder 1587 const char* regular_layer_name = "VK_LAYER_regular_layer_path"; 1588 env.add_explicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 1589 .set_name(regular_layer_name) 1590 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1591 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 1592 "regular_test_layer.json"} 1593 .set_discovery_type(ManifestDiscoveryType::override_folder)); 1594 1595 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1596 ManifestLayer::LayerDescription{} 1597 .set_name(lunarg_meta_layer_name) 1598 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1599 .add_component_layer(regular_layer_name) 1600 .set_disable_environment("DisableMeIfYouCan") 1601 .add_override_path(env.get_folder(ManifestLocation::override_layer).location().str())), 1602 "meta_test_layer.json"); 1603 1604 auto meta_layer_path = env.get_folder(ManifestLocation::override_layer).location(); 1605 1606 InstWrapper inst{env.vulkan_functions}; 1607 inst.create_info.set_api_version(1, 1, 0); 1608 inst.create_info.add_layer(env_var_layer_name); 1609 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1610 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 1611 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + env_var_layer_name)); 1612 ASSERT_TRUE(env.debug_log.find( 1613 std::string("Ignoring VK_LAYER_PATH. The Override layer is active and has override paths set, which takes priority. " 1614 "VK_LAYER_PATH is set to ") + 1615 env.env_var_vk_layer_paths.value())); 1616 ASSERT_TRUE(env.debug_log.find("Override layer has override paths set to " + meta_layer_path.str())); 1617 1618 env.layers.clear(); 1619} 1620 1621// Make sure that implicit layers not in the override paths aren't found by mistake 1622TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) { 1623 FrameworkEnvironment env; 1624 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1625 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1626 1627 const char* implicit_layer_name = "VK_LAYER_ImplicitLayer"; 1628 env.add_implicit_layer( 1629 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1630 .set_name(implicit_layer_name) 1631 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1632 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 1633 "implicit_test_layer.json"); 1634 1635 const char* regular_layer_name = "VK_LAYER_TestLayer_1"; 1636 override_layer_folder.write_manifest("regular_test_layer.json", 1637 ManifestLayer{} 1638 .add_layer(ManifestLayer::LayerDescription{} 1639 .set_name(regular_layer_name) 1640 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1641 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1642 .get_manifest_str()); 1643 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1644 ManifestLayer::LayerDescription{} 1645 .set_name(lunarg_meta_layer_name) 1646 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1647 .add_component_layers({regular_layer_name, implicit_layer_name}) 1648 .set_disable_environment("DisableMeIfYouCan") 1649 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1650 "meta_test_layer.json"); 1651 1652 InstWrapper inst{env.vulkan_functions}; 1653 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1654 inst.create_info.set_api_version(1, 1, 0); 1655 inst.CheckCreate(); 1656 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + implicit_layer_name)); 1657 ASSERT_TRUE( 1658 env.debug_log.find("Removing meta-layer VK_LAYER_LUNARG_override from instance layer list since it appears invalid.")); 1659 env.layers.clear(); 1660} 1661 1662TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) { 1663 FrameworkEnvironment env; 1664 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1665 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1666 1667 const char* regular_layer_name = "VK_LAYER_TestLayer_1"; 1668 override_layer_folder.write_manifest("regular_test_layer.json", 1669 ManifestLayer{} 1670 .add_layer(ManifestLayer::LayerDescription{} 1671 .set_name(regular_layer_name) 1672 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1673 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1674 .get_manifest_str()); 1675 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 0, 0}).add_layer( 1676 ManifestLayer::LayerDescription{} 1677 .set_name(lunarg_meta_layer_name) 1678 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1679 .add_component_layer(regular_layer_name) 1680 .set_disable_environment("DisableMeIfYouCan") 1681 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1682 "meta_test_layer.json"); 1683 1684 InstWrapper inst{env.vulkan_functions}; 1685 inst.create_info.set_api_version(1, 1, 0); 1686 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1687 inst.CheckCreate(); 1688 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1689 ASSERT_TRUE(env.debug_log.find("Indicating meta-layer-specific override paths, but using older JSON file version.")); 1690 env.layers.clear(); 1691} 1692 1693// app_key contains test executable name, should activate the override layer 1694TEST(OverrideMetaLayer, AppKeysDoesContainCurrentApplication) { 1695 FrameworkEnvironment env; 1696 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1697 1698 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1699 env.add_explicit_layer( 1700 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1701 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1702 "regular_test_layer.json"); 1703 1704 std::string cur_path = test_platform_executable_path(); 1705 1706 env.add_implicit_layer( 1707 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 1708 .set_name(lunarg_meta_layer_name) 1709 .add_component_layers({regular_layer_name}) 1710 .set_disable_environment("DisableMeIfYouCan") 1711 .add_app_key(cur_path)), 1712 "meta_test_layer.json"); 1713 { // global functions 1714 auto layer_props = env.GetLayerProperties(2); 1715 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1716 } 1717 { 1718 // instance 1719 InstWrapper inst{env.vulkan_functions}; 1720 inst.CheckCreate(); 1721 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1722 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1723 } 1724} 1725 1726// app_key contains random strings, should not activate the override layer 1727TEST(OverrideMetaLayer, AppKeysDoesNotContainCurrentApplication) { 1728 FrameworkEnvironment env; 1729 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1730 1731 const char* regular_layer_name = "VK_LAYER_TestLayer"; 1732 env.add_explicit_layer( 1733 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1734 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 1735 "regular_test_layer.json"); 1736 1737 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1738 ManifestLayer::LayerDescription{} 1739 .set_name(lunarg_meta_layer_name) 1740 .add_component_layers({regular_layer_name}) 1741 .set_disable_environment("DisableMeIfYouCan") 1742 .add_app_keys({"/Hello", "Hi", "./../Uh-oh", "C:/Windows/Only"})), 1743 "meta_test_layer.json"); 1744 { // global functions 1745 auto layer_props = env.GetLayerProperties(1); 1746 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 1747 } 1748 { 1749 // instance 1750 InstWrapper inst{env.vulkan_functions}; 1751 inst.CheckCreate(); 1752 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 1753 } 1754} 1755 1756TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromSecureLocation) { 1757 FrameworkEnvironment env; 1758 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1759 1760 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1761 1762 const char* regular_layer_name = "VK_LAYER_TestLayer_1"; 1763 override_layer_folder.write_manifest("regular_test_layer.json", 1764 ManifestLayer{} 1765 .add_layer(ManifestLayer::LayerDescription{} 1766 .set_name(regular_layer_name) 1767 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1768 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1769 .get_manifest_str()); 1770 auto override_folder_location = fs::make_native(override_layer_folder.location().str()); 1771 env.add_implicit_layer(TestLayerDetails{ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1772 ManifestLayer::LayerDescription{} 1773 .set_name(lunarg_meta_layer_name) 1774 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1775 .add_component_layer(regular_layer_name) 1776 .set_disable_environment("DisableMeIfYouCan") 1777 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1778 "meta_test_layer.json"}); 1779 1780 { // try with no elevated privileges 1781 auto layer_props = env.GetLayerProperties(2); 1782 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1783 1784 InstWrapper inst{env.vulkan_functions}; 1785 inst.create_info.set_api_version(1, 1, 0); 1786 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1787 inst.CheckCreate(); 1788 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1789 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1790 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1791 env.debug_log.clear(); 1792 } 1793 1794 env.platform_shim->set_elevated_privilege(true); 1795 1796 { // try with elevated privileges 1797 auto layer_props = env.GetLayerProperties(2); 1798 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1799 1800 InstWrapper inst{env.vulkan_functions}; 1801 inst.create_info.set_api_version(1, 1, 0); 1802 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1803 inst.CheckCreate(); 1804 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1805 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1806 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, active_layer_props)); 1807 } 1808} 1809 1810// Override layer should not be found and thus not loaded when running with elevated privileges 1811TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromUnsecureLocation) { 1812 FrameworkEnvironment env; 1813 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1814 1815 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"}; 1816 1817 const char* regular_layer_name = "VK_LAYER_TestLayer_1"; 1818 override_layer_folder.write_manifest("regular_test_layer.json", 1819 ManifestLayer{} 1820 .add_layer(ManifestLayer::LayerDescription{} 1821 .set_name(regular_layer_name) 1822 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1823 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))) 1824 .get_manifest_str()); 1825 env.add_implicit_layer(TestLayerDetails{ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 1826 ManifestLayer::LayerDescription{} 1827 .set_name(lunarg_meta_layer_name) 1828 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 1829 .add_component_layer(regular_layer_name) 1830 .set_disable_environment("DisableMeIfYouCan") 1831 .add_override_path(fs::make_native(override_layer_folder.location().str()))), 1832 "meta_test_layer.json"} 1833 .set_discovery_type(ManifestDiscoveryType::unsecured_generic)); 1834 1835 { // try with no elevated privileges 1836 auto layer_props = env.GetLayerProperties(2); 1837 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props)); 1838 1839 InstWrapper inst{env.vulkan_functions}; 1840 inst.create_info.set_api_version(1, 1, 0); 1841 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1842 inst.CheckCreate(); 1843 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1844 env.debug_log.clear(); 1845 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1846 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, active_layer_props)); 1847 } 1848 1849 env.platform_shim->set_elevated_privilege(true); 1850 1851 { // try with no elevated privileges 1852 ASSERT_NO_FATAL_FAILURE(env.GetLayerProperties(0)); 1853 1854 InstWrapper inst{env.vulkan_functions}; 1855 inst.create_info.set_api_version(1, 1, 0); 1856 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 1857 inst.CheckCreate(); 1858 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 1859 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 1860 } 1861} 1862 1863// Makes sure explicit layers can't override pre-instance functions even if enabled by the override layer 1864TEST(ExplicitLayers, OverridePreInstanceFunctions) { 1865 FrameworkEnvironment env; 1866 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1867 const char* explicit_layer_name = "VK_LAYER_enabled_by_override"; 1868 const char* disable_env_var = "DISABLE_ME"; 1869 1870 env.add_explicit_layer( 1871 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1872 ManifestLayer::LayerDescription{} 1873 .set_name(explicit_layer_name) 1874 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1875 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1876 .set_vk_func("vkEnumerateInstanceLayerProperties") 1877 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties")) 1878 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1879 .set_vk_func("vkEnumerateInstanceExtensionProperties") 1880 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties")) 1881 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1882 .set_vk_func("vkEnumerateInstanceVersion") 1883 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))), 1884 "explicit_test_layer.json"); 1885 1886 auto& layer = env.get_test_layer(0); 1887 layer.set_reported_layer_props(34); 1888 layer.set_reported_extension_props(22); 1889 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1)); 1890 1891 env.add_implicit_layer( 1892 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{} 1893 .set_name(lunarg_meta_layer_name) 1894 .add_component_layers({explicit_layer_name}) 1895 .set_disable_environment(disable_env_var)), 1896 "override_meta_layer.json"); 1897 1898 uint32_t count = 0; 1899 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr)); 1900 ASSERT_EQ(count, 2U); 1901 count = 0; 1902 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr)); 1903 ASSERT_EQ(count, 4U); 1904 1905 uint32_t version = 0; 1906 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version)); 1907 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE); 1908 1909 InstWrapper inst{env.vulkan_functions}; 1910 inst.CheckCreate(); 1911 1912 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2); 1913 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name)); 1914 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name)); 1915} 1916 1917TEST(ExplicitLayers, LayerSettingsPreInstanceFunctions) { 1918 FrameworkEnvironment env; 1919 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1920 const char* explicit_layer_name = "VK_LAYER_enabled_by_override"; 1921 1922 env.add_explicit_layer( 1923 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1924 ManifestLayer::LayerDescription{} 1925 .set_name(explicit_layer_name) 1926 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1927 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1928 .set_vk_func("vkEnumerateInstanceLayerProperties") 1929 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties")) 1930 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1931 .set_vk_func("vkEnumerateInstanceExtensionProperties") 1932 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties")) 1933 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1934 .set_vk_func("vkEnumerateInstanceVersion") 1935 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))), 1936 "explicit_test_layer.json"); 1937 1938 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 1939 LoaderSettingsLayerConfiguration{} 1940 .set_name(explicit_layer_name) 1941 .set_control("on") 1942 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 1943 .set_treat_as_implicit_manifest(false))); 1944 env.update_loader_settings(env.loader_settings); 1945 1946 auto& layer = env.get_test_layer(0); 1947 layer.set_reported_layer_props(34); 1948 layer.set_reported_extension_props(22); 1949 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1)); 1950 1951 uint32_t count = 0; 1952 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr)); 1953 ASSERT_EQ(count, 1U); 1954 count = 0; 1955 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr)); 1956 ASSERT_EQ(count, 4U); 1957 1958 uint32_t version = 0; 1959 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version)); 1960 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE); 1961 1962 InstWrapper inst{env.vulkan_functions}; 1963 inst.CheckCreate(); 1964 1965 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 1966 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name)); 1967} 1968 1969TEST(ExplicitLayers, ContainsPreInstanceFunctions) { 1970 FrameworkEnvironment env; 1971 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 1972 const char* explicit_layer_name = "VK_LAYER_enabled_by_override"; 1973 1974 env.add_explicit_layer( 1975 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 1976 ManifestLayer::LayerDescription{} 1977 .set_name(explicit_layer_name) 1978 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 1979 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1980 .set_vk_func("vkEnumerateInstanceLayerProperties") 1981 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties")) 1982 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1983 .set_vk_func("vkEnumerateInstanceExtensionProperties") 1984 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties")) 1985 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{} 1986 .set_vk_func("vkEnumerateInstanceVersion") 1987 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))), 1988 "explicit_test_layer.json"); 1989 1990 auto& layer = env.get_test_layer(0); 1991 layer.set_reported_layer_props(34); 1992 layer.set_reported_extension_props(22); 1993 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1)); 1994 1995 uint32_t count = 0; 1996 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr)); 1997 ASSERT_EQ(count, 1U); 1998 count = 0; 1999 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr)); 2000 ASSERT_EQ(count, 4U); 2001 2002 uint32_t version = 0; 2003 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version)); 2004 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE); 2005 2006 InstWrapper inst{env.vulkan_functions}; 2007 inst.create_info.add_layer(explicit_layer_name); 2008 inst.CheckCreate(); 2009 2010 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2011 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name)); 2012} 2013 2014// This test makes sure that any layer calling GetPhysicalDeviceProperties2 inside of CreateInstance 2015// succeeds and doesn't crash. 2016TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) { 2017 FrameworkEnvironment env; 2018 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)) 2019 .add_physical_device({}) 2020 .set_icd_api_version(VK_API_VERSION_1_1); 2021 2022 const char* regular_layer_name = "VK_LAYER_TestLayer"; 2023 env.add_explicit_layer( 2024 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer( 2025 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2026 "regular_test_layer.json"); 2027 2028 auto& layer_handle = env.get_test_layer(0); 2029 layer_handle.set_create_instance_callback([](TestLayer& layer) -> VkResult { 2030 uint32_t phys_dev_count = 0; 2031 VkResult res = layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, nullptr); 2032 if (res != VK_SUCCESS || phys_dev_count > 1) { 2033 return VK_ERROR_INITIALIZATION_FAILED; // expecting only a single physical device. 2034 } 2035 VkPhysicalDevice phys_dev{}; 2036 res = layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, &phys_dev); 2037 if (res != VK_SUCCESS) { 2038 return VK_ERROR_INITIALIZATION_FAILED; 2039 } 2040 VkPhysicalDeviceProperties2 props2{}; 2041 props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; 2042 layer.instance_dispatch_table.GetPhysicalDeviceProperties2(phys_dev, &props2); 2043 2044 VkPhysicalDeviceFeatures2 features2{}; 2045 features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2046 layer.instance_dispatch_table.GetPhysicalDeviceFeatures2(phys_dev, &features2); 2047 return VK_SUCCESS; 2048 }); 2049 2050 InstWrapper inst{env.vulkan_functions}; 2051 inst.create_info.add_layer(regular_layer_name).set_api_version(1, 1, 0); 2052 inst.CheckCreate(); 2053} 2054 2055TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) { 2056 FrameworkEnvironment env; 2057 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)) 2058 .add_physical_device({}) 2059 .add_instance_extension({"VK_KHR_get_physical_device_properties2", 0}); 2060 2061 const char* regular_layer_name = "VK_LAYER_TestLayer"; 2062 env.add_explicit_layer( 2063 ManifestLayer{}.add_layer( 2064 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2065 "regular_test_layer.json"); 2066 2067 auto& layer_handle = env.get_test_layer(0); 2068 layer_handle.set_create_instance_callback([](TestLayer& layer) -> VkResult { 2069 uint32_t phys_dev_count = 1; 2070 VkPhysicalDevice phys_dev{}; 2071 layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, &phys_dev); 2072 2073 VkPhysicalDeviceProperties2KHR props2{}; 2074 props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR; 2075 layer.instance_dispatch_table.GetPhysicalDeviceProperties2KHR(phys_dev, &props2); 2076 2077 VkPhysicalDeviceFeatures2KHR features2{}; 2078 features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR; 2079 layer.instance_dispatch_table.GetPhysicalDeviceFeatures2KHR(phys_dev, &features2); 2080 return VK_SUCCESS; 2081 }); 2082 2083 InstWrapper inst{env.vulkan_functions}; 2084 inst.create_info.add_layer(regular_layer_name).add_extension("VK_KHR_get_physical_device_properties2"); 2085 inst.CheckCreate(); 2086} 2087 2088TEST(ExplicitLayers, MultipleLayersInSingleManifest) { 2089 FrameworkEnvironment env; 2090 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2091 2092 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2093 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1"; 2094 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2"; 2095 const char* regular_layer_name_3 = "VK_LAYER_RegularLayer3"; 2096 env.add_explicit_layer(TestLayerDetails( 2097 ManifestLayer{} 2098 .set_file_format_version({1, 0, 1}) 2099 .add_layer( 2100 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)) 2101 .add_layer( 2102 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)) 2103 .add_layer( 2104 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_3).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2105 "multi_layer_manifest.json")); 2106 2107 auto layer_props = env.GetLayerProperties(3); 2108 ASSERT_TRUE(string_eq(regular_layer_name_1, layer_props[0].layerName)); 2109 ASSERT_TRUE(string_eq(regular_layer_name_2, layer_props[1].layerName)); 2110 ASSERT_TRUE(string_eq(regular_layer_name_3, layer_props[2].layerName)); 2111} 2112 2113TEST(ExplicitLayers, WrapObjects) { 2114 FrameworkEnvironment env; 2115 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0"); 2116 2117 const char* wrap_objects_name = "VK_LAYER_LUNARG_wrap_objects"; 2118 env.add_explicit_layer(ManifestLayer{}.add_layer( 2119 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)), 2120 "wrap_objects_layer.json"); 2121 2122 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1"; 2123 env.add_explicit_layer( 2124 ManifestLayer{}.add_layer( 2125 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2126 "regular_layer_1.json"); 2127 2128 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2"; 2129 env.add_explicit_layer( 2130 ManifestLayer{}.add_layer( 2131 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2132 "regular_layer_2.json"); 2133 2134 { // just the wrap layer 2135 InstWrapper inst{env.vulkan_functions}; 2136 inst.create_info.add_layer(wrap_objects_name); 2137 inst.CheckCreate(); 2138 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 2139 2140 DeviceWrapper dev{inst}; 2141 dev.CheckCreate(phys_dev); 2142 } 2143 { // wrap layer first 2144 InstWrapper inst{env.vulkan_functions}; 2145 inst.create_info.add_layer(wrap_objects_name).add_layer(regular_layer_name_1); 2146 inst.CheckCreate(); 2147 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 2148 2149 DeviceWrapper dev{inst}; 2150 dev.CheckCreate(phys_dev); 2151 } 2152 { // wrap layer last 2153 InstWrapper inst{env.vulkan_functions}; 2154 inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name); 2155 inst.CheckCreate(); 2156 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 2157 2158 DeviceWrapper dev{inst}; 2159 dev.CheckCreate(phys_dev); 2160 } 2161 { // wrap layer last 2162 InstWrapper inst{env.vulkan_functions}; 2163 inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name).add_layer(regular_layer_name_2); 2164 inst.CheckCreate(); 2165 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 2166 2167 DeviceWrapper dev{inst}; 2168 dev.CheckCreate(phys_dev); 2169 } 2170} 2171 2172TEST(ExplicitLayers, VkLayerPathEnvVar) { 2173 FrameworkEnvironment env; 2174 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2175 2176 { 2177 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2178 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1"; 2179 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2180 .set_name(regular_layer_name_1) 2181 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2182 "regular_layer_1.json") 2183 .set_discovery_type(ManifestDiscoveryType::env_var) 2184 .set_is_dir(false)); 2185 2186 InstWrapper inst(env.vulkan_functions); 2187 inst.create_info.add_layer(regular_layer_name_1); 2188 inst.CheckCreate(VK_SUCCESS); 2189 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2190 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name_1)); 2191 } 2192 { 2193 // verify layers load successfully when setting VK_LAYER_PATH to multiple full filepaths 2194 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1"; 2195 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2196 .set_name(regular_layer_name_1) 2197 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2198 "regular_layer_1.json") 2199 .set_discovery_type(ManifestDiscoveryType::env_var) 2200 .set_is_dir(false)); 2201 2202 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2"; 2203 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2204 .set_name(regular_layer_name_2) 2205 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2206 "regular_layer_2.json") 2207 .set_discovery_type(ManifestDiscoveryType::env_var) 2208 .set_is_dir(false)); 2209 2210 InstWrapper inst(env.vulkan_functions); 2211 inst.create_info.add_layer(regular_layer_name_1); 2212 inst.create_info.add_layer(regular_layer_name_2); 2213 inst.CheckCreate(VK_SUCCESS); 2214 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2215 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props)); 2216 } 2217 { 2218 // verify layers load successfully when setting VK_LAYER_PATH to a directory 2219 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1"; 2220 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2221 .set_name(regular_layer_name_1) 2222 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2223 "regular_layer_1.json") 2224 .set_discovery_type(ManifestDiscoveryType::env_var)); 2225 2226 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2"; 2227 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2228 .set_name(regular_layer_name_2) 2229 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2230 "regular_layer_2.json") 2231 .set_discovery_type(ManifestDiscoveryType::env_var)); 2232 2233 InstWrapper inst(env.vulkan_functions); 2234 inst.create_info.add_layer(regular_layer_name_1); 2235 inst.create_info.add_layer(regular_layer_name_2); 2236 inst.CheckCreate(VK_SUCCESS); 2237 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2238 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props)); 2239 } 2240} 2241 2242TEST(ExplicitLayers, DuplicateLayersInVK_LAYER_PATH) { 2243 FrameworkEnvironment env; 2244 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2245 2246 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2247 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1"; 2248 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2249 .set_name(same_layer_name_1) 2250 .set_description("actually_layer_1") 2251 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2252 "regular_layer_1.json") 2253 // use override folder as just a folder and manually set the VK_LAYER_PATH env-var to it 2254 .set_discovery_type(ManifestDiscoveryType::override_folder) 2255 .set_is_dir(true)); 2256 auto& layer1 = env.get_test_layer(0); 2257 layer1.set_description("actually_layer_1"); 2258 layer1.set_make_spurious_log_in_create_instance("actually_layer_1"); 2259 env.env_var_vk_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location().str()); 2260 2261 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2262 .set_name(same_layer_name_1) 2263 .set_description("actually_layer_2") 2264 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2265 "regular_layer_1.json") 2266 .set_discovery_type(ManifestDiscoveryType::env_var) 2267 .set_is_dir(true)); 2268 auto& layer2 = env.get_test_layer(1); 2269 layer2.set_description("actually_layer_2"); 2270 layer2.set_make_spurious_log_in_create_instance("actually_layer_2"); 2271 2272 auto layer_props = env.GetLayerProperties(2); 2273 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName)); 2274 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName)); 2275 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 2276 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 2277 { 2278 InstWrapper inst{env.vulkan_functions}; 2279 inst.create_info.add_layer(same_layer_name_1); 2280 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2281 inst.CheckCreate(); 2282 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2283 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2284 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2285 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2286 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2287 } 2288 env.debug_log.clear(); 2289 2290 { 2291 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", same_layer_name_1}; 2292 InstWrapper inst{env.vulkan_functions}; 2293 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2294 inst.CheckCreate(); 2295 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2296 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2297 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2298 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2299 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2300 } 2301 env.debug_log.clear(); 2302 2303 { 2304 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", same_layer_name_1}; 2305 InstWrapper inst{env.vulkan_functions}; 2306 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2307 inst.CheckCreate(); 2308 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2309 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2310 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2311 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2312 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2313 } 2314 env.debug_log.clear(); 2315} 2316 2317TEST(ExplicitLayers, DuplicateLayersInVK_ADD_LAYER_PATH) { 2318 FrameworkEnvironment env; 2319 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2320 2321 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2322 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1"; 2323 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2324 .set_name(same_layer_name_1) 2325 .set_description("actually_layer_1") 2326 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2327 "regular_layer_1.json") 2328 // use override folder as just a folder and manually set the VK_ADD_LAYER_PATH env-var to it 2329 .set_discovery_type(ManifestDiscoveryType::override_folder) 2330 .set_is_dir(true)); 2331 auto& layer1 = env.get_test_layer(0); 2332 layer1.set_description("actually_layer_1"); 2333 layer1.set_make_spurious_log_in_create_instance("actually_layer_1"); 2334 env.add_env_var_vk_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location().str()); 2335 2336 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2337 .set_name(same_layer_name_1) 2338 .set_description("actually_layer_2") 2339 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2340 "regular_layer_1.json") 2341 .set_discovery_type(ManifestDiscoveryType::add_env_var) 2342 .set_is_dir(true)); 2343 auto& layer2 = env.get_test_layer(1); 2344 layer2.set_description("actually_layer_2"); 2345 layer2.set_make_spurious_log_in_create_instance("actually_layer_2"); 2346 2347 auto layer_props = env.GetLayerProperties(2); 2348 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName)); 2349 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName)); 2350 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 2351 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 2352 { 2353 InstWrapper inst{env.vulkan_functions}; 2354 inst.create_info.add_layer(same_layer_name_1); 2355 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2356 inst.CheckCreate(); 2357 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2358 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2359 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2360 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2361 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2362 } 2363 env.debug_log.clear(); 2364 2365 { 2366 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", same_layer_name_1}; 2367 InstWrapper inst{env.vulkan_functions}; 2368 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2369 inst.CheckCreate(); 2370 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2371 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2372 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2373 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2374 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2375 } 2376 env.debug_log.clear(); 2377 2378 { 2379 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", same_layer_name_1}; 2380 InstWrapper inst{env.vulkan_functions}; 2381 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2382 inst.CheckCreate(); 2383 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 2384 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName)); 2385 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description)); 2386 ASSERT_TRUE(env.debug_log.find("actually_layer_1")); 2387 ASSERT_FALSE(env.debug_log.find("actually_layer_2")); 2388 } 2389 env.debug_log.clear(); 2390} 2391 2392TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayers) { 2393 FrameworkEnvironment env; 2394 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2395 2396 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2397 const char* layer_name_1 = "VK_LAYER_RegularLayer1"; 2398 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2399 .set_name(layer_name_1) 2400 .set_description("actually_layer_1") 2401 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2402 "regular_layer_1.json") 2403 .set_discovery_type(ManifestDiscoveryType::env_var) 2404 .set_is_dir(true)); 2405 auto& layer1 = env.get_test_layer(0); 2406 layer1.set_description("actually_layer_1"); 2407 2408 const char* layer_name_2 = "VK_LAYER_RegularLayer2"; 2409 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2410 .set_name(layer_name_2) 2411 .set_description("actually_layer_2") 2412 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2413 "regular_layer_2.json") 2414 .set_discovery_type(ManifestDiscoveryType::env_var) 2415 .set_is_dir(true)); 2416 auto& layer2 = env.get_test_layer(1); 2417 layer2.set_description("actually_layer_2"); 2418 2419 auto layer_props = env.GetLayerProperties(2); 2420 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName)); 2421 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName)); 2422 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 2423 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 2424 // 1 then 2 2425 { 2426 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"}; 2427 inst_layers_env_var.add_to_list(layer_name_1); 2428 inst_layers_env_var.add_to_list(layer_name_2); 2429 2430 InstWrapper inst{env.vulkan_functions}; 2431 inst.CheckCreate(); 2432 2433 // Expect the env-var layer to be first 2434 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2435 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description)); 2436 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description)); 2437 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName)); 2438 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName)); 2439 } 2440 // 2 then 1 2441 { 2442 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"}; 2443 inst_layers_env_var.add_to_list(layer_name_2); 2444 inst_layers_env_var.add_to_list(layer_name_1); 2445 2446 InstWrapper inst{env.vulkan_functions}; 2447 inst.CheckCreate(); 2448 2449 // Expect the env-var layer to be first 2450 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2451 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description)); 2452 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description)); 2453 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName)); 2454 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName)); 2455 } 2456} 2457 2458TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayersFromSystemLocations) { 2459 FrameworkEnvironment env; 2460 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2461 2462 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2463 const char* layer_name_1 = "VK_LAYER_RegularLayer1"; 2464 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2465 .set_name(layer_name_1) 2466 .set_description("actually_layer_1") 2467 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2468 "regular_layer_1.json")); 2469 auto& layer1 = env.get_test_layer(0); 2470 layer1.set_description("actually_layer_1"); 2471 2472 const char* layer_name_2 = "VK_LAYER_RegularLayer2"; 2473 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2474 .set_name(layer_name_2) 2475 .set_description("actually_layer_2") 2476 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2477 "regular_layer_2.json")); 2478 auto& layer2 = env.get_test_layer(1); 2479 layer2.set_description("actually_layer_2"); 2480 2481 auto layer_props = env.GetLayerProperties(2); 2482 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName)); 2483 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName)); 2484 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 2485 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 2486 // 1 then 2 2487 { 2488 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"}; 2489 inst_layers_env_var.add_to_list(layer_name_1); 2490 inst_layers_env_var.add_to_list(layer_name_2); 2491 2492 InstWrapper inst{env.vulkan_functions}; 2493 inst.CheckCreate(); 2494 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2495 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description)); 2496 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description)); 2497 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName)); 2498 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName)); 2499 } 2500 // 2 then 1 2501 { 2502 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"}; 2503 inst_layers_env_var.add_to_list(layer_name_2); 2504 inst_layers_env_var.add_to_list(layer_name_1); 2505 2506 InstWrapper inst{env.vulkan_functions}; 2507 inst.CheckCreate(); 2508 2509 // Expect the env-var layer to be first 2510 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2511 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description)); 2512 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description)); 2513 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName)); 2514 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName)); 2515 } 2516} 2517 2518TEST(ExplicitLayers, CorrectOrderOfApplicationEnabledLayers) { 2519 FrameworkEnvironment env; 2520 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2521 2522 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath 2523 const char* layer_name_1 = "VK_LAYER_RegularLayer1"; 2524 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2525 .set_name(layer_name_1) 2526 .set_description("actually_layer_1") 2527 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2528 "regular_layer_1.json")); 2529 auto& layer1 = env.get_test_layer(0); 2530 layer1.set_description("actually_layer_1"); 2531 layer1.set_make_spurious_log_in_create_instance("actually_layer_1"); 2532 2533 const char* layer_name_2 = "VK_LAYER_RegularLayer2"; 2534 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2535 .set_name(layer_name_2) 2536 .set_description("actually_layer_2") 2537 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 2538 "regular_layer_2.json")); 2539 auto& layer2 = env.get_test_layer(1); 2540 layer2.set_description("actually_layer_2"); 2541 layer2.set_make_spurious_log_in_create_instance("actually_layer_2"); 2542 2543 auto layer_props = env.GetLayerProperties(2); 2544 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName)); 2545 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName)); 2546 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description)); 2547 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description)); 2548 2549 // 1 then 2 2550 { 2551 InstWrapper inst{env.vulkan_functions}; 2552 inst.create_info.add_layer(layer_name_1); 2553 inst.create_info.add_layer(layer_name_2); 2554 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2555 inst.CheckCreate(); 2556 2557 // Expect the env-var layer to be first 2558 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2559 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description)); 2560 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description)); 2561 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName)); 2562 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName)); 2563 } 2564 // 2 then 1 2565 { 2566 InstWrapper inst{env.vulkan_functions}; 2567 inst.create_info.add_layer(layer_name_2); 2568 inst.create_info.add_layer(layer_name_1); 2569 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 2570 inst.CheckCreate(); 2571 2572 // Expect the env-var layer to be first 2573 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2); 2574 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description)); 2575 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description)); 2576 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName)); 2577 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName)); 2578 } 2579} 2580 2581TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) { 2582 FrameworkEnvironment env; 2583 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2584 2585 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2586 const char* enable_env_var = "ENABLE_ME"; 2587 const char* disable_env_var = "DISABLE_ME"; 2588 2589 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2590 .set_name(implicit_layer_name) 2591 .set_lib_path(TEST_LAYER_WRAP_OBJECTS) 2592 .set_disable_environment(disable_env_var) 2593 .set_enable_environment(enable_env_var)), 2594 "implicit_wrap_layer_no_ext.json"); 2595 2596 auto layers = env.GetLayerProperties(1); 2597 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 2598 2599 // set enable env-var, layer should load 2600 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 2601 CheckLogForLayerString(env, implicit_layer_name, true); 2602 2603 auto extensions = env.GetInstanceExtensions(4); 2604 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2605 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2606 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2607 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2608 2609 // Make sure the extensions that are implemented only in the test layers is not present. 2610 ASSERT_FALSE(contains(extensions, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)); 2611 ASSERT_FALSE(contains(extensions, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2612 2613 InstWrapper inst{env.vulkan_functions}; 2614 inst.CheckCreate(); 2615 2616 // Make sure all the function pointers are NULL as well 2617 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT")); 2618 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2619} 2620 2621TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) { 2622 FrameworkEnvironment env; 2623 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2624 2625 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2626 const char* enable_env_var = "ENABLE_ME"; 2627 const char* disable_env_var = "DISABLE_ME"; 2628 2629 env.add_implicit_layer( 2630 ManifestLayer{}.add_layer( 2631 ManifestLayer::LayerDescription{} 2632 .set_name(implicit_layer_name) 2633 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1) 2634 .set_disable_environment(disable_env_var) 2635 .set_enable_environment(enable_env_var) 2636 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})), 2637 "implicit_wrap_layer_dir_disp_mode.json"); 2638 2639 auto layers = env.GetLayerProperties(1); 2640 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 2641 2642 // set enable env-var, layer should load 2643 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 2644 CheckLogForLayerString(env, implicit_layer_name, true); 2645 2646 auto extensions = env.GetInstanceExtensions(5); 2647 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2648 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2649 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2650 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2651 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)); 2652 2653 // Make sure the extensions that are implemented only in the test layers is not present. 2654 ASSERT_FALSE(contains(extensions, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2655 2656 InstWrapper inst{env.vulkan_functions}; 2657 inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME); 2658 inst.CheckCreate(); 2659 2660 // Make sure only the appropriate function pointers are NULL as well 2661 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT")); 2662 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2663} 2664 2665TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) { 2666 FrameworkEnvironment env; 2667 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2668 2669 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2670 const char* enable_env_var = "ENABLE_ME"; 2671 const char* disable_env_var = "DISABLE_ME"; 2672 2673 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2674 .set_name(implicit_layer_name) 2675 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2) 2676 .set_disable_environment(disable_env_var) 2677 .set_enable_environment(enable_env_var) 2678 .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 2679 1, 2680 {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})), 2681 "implicit_wrap_layer_disp_surf_count.json"); 2682 2683 auto layers = env.GetLayerProperties(1); 2684 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 2685 2686 // set enable env-var, layer should load 2687 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 2688 CheckLogForLayerString(env, implicit_layer_name, true); 2689 2690 auto extensions = env.GetInstanceExtensions(5); 2691 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2692 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2693 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2694 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2695 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2696 2697 InstWrapper inst{env.vulkan_functions}; 2698 inst.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2699 inst.CheckCreate(); 2700 2701 // Make sure only the appropriate function pointers are NULL as well 2702 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT")); 2703 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2704} 2705 2706TEST(LayerExtensions, ImplicitBothInstanceExtensions) { 2707 FrameworkEnvironment env; 2708 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2709 2710 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2711 const char* enable_env_var = "ENABLE_ME"; 2712 const char* disable_env_var = "DISABLE_ME"; 2713 2714 env.add_implicit_layer( 2715 ManifestLayer{}.add_layer( 2716 ManifestLayer::LayerDescription{} 2717 .set_name(implicit_layer_name) 2718 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 2719 .set_disable_environment(disable_env_var) 2720 .set_enable_environment(enable_env_var) 2721 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}}) 2722 .add_instance_extension( 2723 {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})), 2724 "implicit_wrap_layer_both_inst.json"); 2725 2726 auto layers = env.GetLayerProperties(1); 2727 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 2728 2729 // set enable env-var, layer should load 2730 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 2731 CheckLogForLayerString(env, implicit_layer_name, true); 2732 2733 auto extensions = env.GetInstanceExtensions(6); 2734 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2735 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2736 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2737 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2738 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)); 2739 EXPECT_TRUE(string_eq(extensions.at(5).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2740 2741 InstWrapper inst{env.vulkan_functions}; 2742 inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME) 2743 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2744 inst.CheckCreate(); 2745 2746 // Make sure only the appropriate function pointers are NULL as well 2747 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT")); 2748 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2749} 2750 2751TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) { 2752 FrameworkEnvironment env; 2753 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2754 2755 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2756 env.add_explicit_layer( 2757 ManifestLayer{}.add_layer( 2758 ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)), 2759 "explicit_wrap_layer_no_ext.json"); 2760 2761 auto layers = env.GetLayerProperties(1); 2762 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 2763 2764 auto extensions = env.GetInstanceExtensions(4); 2765 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2766 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2767 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2768 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2769 2770 // Now query by layer name. 2771 ASSERT_NO_FATAL_FAILURE(env.GetInstanceExtensions(0, explicit_layer_name)); 2772 2773 InstWrapper inst{env.vulkan_functions}; 2774 inst.CheckCreate(); 2775 2776 // Make sure all the function pointers are NULL as well 2777 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT")); 2778 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2779} 2780 2781TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) { 2782 FrameworkEnvironment env; 2783 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2784 2785 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2786 env.add_explicit_layer( 2787 ManifestLayer{}.add_layer( 2788 ManifestLayer::LayerDescription{} 2789 .set_name(explicit_layer_name) 2790 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1) 2791 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})), 2792 "explicit_wrap_layer_dir_disp_mode.json"); 2793 2794 auto layers = env.GetLayerProperties(1); 2795 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 2796 2797 auto extensions = env.GetInstanceExtensions(4); 2798 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2799 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2800 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2801 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2802 2803 // Now query by layer name. 2804 auto layer_extensions = env.GetInstanceExtensions(1, explicit_layer_name); 2805 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)); 2806 2807 InstWrapper inst1{env.vulkan_functions}; 2808 inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME); 2809 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT); 2810 2811 // Make sure only the appropriate function pointers are NULL as well 2812 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT")); 2813 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2814 2815 InstWrapper inst2{env.vulkan_functions}; 2816 inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME); 2817 inst2.CheckCreate(); 2818 2819 // Make sure only the appropriate function pointers are NULL as well 2820 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT")); 2821 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2822} 2823 2824TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) { 2825 FrameworkEnvironment env; 2826 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2827 2828 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2829 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2830 .set_name(explicit_layer_name) 2831 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2) 2832 .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 2833 1, 2834 {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})), 2835 "explicit_wrap_layer_disp_surf_count.json"); 2836 2837 auto layers = env.GetLayerProperties(1); 2838 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 2839 2840 auto extensions = env.GetInstanceExtensions(4); 2841 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2842 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2843 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2844 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2845 2846 // Now query by layer name. 2847 auto layer_extensions = env.GetInstanceExtensions(1, explicit_layer_name); 2848 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2849 2850 InstWrapper inst1{env.vulkan_functions}; 2851 inst1.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2852 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT); 2853 2854 // Make sure only the appropriate function pointers are NULL as well 2855 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT")); 2856 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2857 2858 InstWrapper inst2{env.vulkan_functions}; 2859 inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2860 inst2.CheckCreate(); 2861 2862 // Make sure only the appropriate function pointers are NULL as well 2863 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT")); 2864 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2865} 2866 2867TEST(LayerExtensions, ExplicitBothInstanceExtensions) { 2868 FrameworkEnvironment env; 2869 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2870 2871 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2872 env.add_explicit_layer( 2873 ManifestLayer{}.add_layer( 2874 ManifestLayer::LayerDescription{} 2875 .set_name(explicit_layer_name) 2876 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 2877 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}}) 2878 .add_instance_extension( 2879 {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})), 2880 "explicit_wrap_layer_both_inst.json"); 2881 2882 auto layers = env.GetLayerProperties(1); 2883 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 2884 2885 auto extensions = env.GetInstanceExtensions(4); 2886 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME)); 2887 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)); 2888 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)); 2889 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME)); 2890 2891 // Make sure the extensions still aren't present in this layer 2892 auto layer_extensions = env.GetInstanceExtensions(2, explicit_layer_name); 2893 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)); 2894 EXPECT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)); 2895 2896 InstWrapper inst1{env.vulkan_functions}; 2897 inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME) 2898 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2899 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT); 2900 2901 // Make sure only the appropriate function pointers are NULL as well 2902 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT")); 2903 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); 2904 2905 InstWrapper inst2{env.vulkan_functions}; 2906 inst2.create_info.add_layer(explicit_layer_name) 2907 .add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME) 2908 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); 2909 inst2.CheckCreate(); 2910 VkPhysicalDevice phys_dev = inst2.GetPhysDev(); 2911 2912 // Make sure only the appropriate function pointers are NULL as well 2913 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT")); 2914 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT pfnGetPhysicalDeviceSurfaceCapabilities2EXT = 2915 inst2.load("vkGetPhysicalDeviceSurfaceCapabilities2EXT"); 2916 handle_assert_has_value(pfnGetPhysicalDeviceSurfaceCapabilities2EXT); 2917 2918 VkSurfaceCapabilities2EXT surf_caps{VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT}; 2919 2920 // Call and then check a few things 2921 ASSERT_EQ(VK_SUCCESS, pfnGetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev, VK_NULL_HANDLE, &surf_caps)); 2922 ASSERT_EQ(7U, surf_caps.minImageCount); 2923 ASSERT_EQ(12U, surf_caps.maxImageCount); 2924 ASSERT_EQ(365U, surf_caps.maxImageArrayLayers); 2925} 2926 2927TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) { 2928 FrameworkEnvironment env; 2929 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2930 2931 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2932 const char* enable_env_var = "ENABLE_ME"; 2933 const char* disable_env_var = "DISABLE_ME"; 2934 2935 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2936 .set_name(implicit_layer_name) 2937 .set_lib_path(TEST_LAYER_WRAP_OBJECTS) 2938 .set_disable_environment(disable_env_var) 2939 .set_enable_environment(enable_env_var)), 2940 "implicit_wrap_layer_no_ext.json"); 2941 2942 auto layers = env.GetLayerProperties(1); 2943 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 2944 2945 // set enable env-var, layer should load 2946 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 2947 CheckLogForLayerString(env, implicit_layer_name, true); 2948 2949 InstWrapper inst{env.vulkan_functions}; 2950 inst.CheckCreate(); 2951 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 2952 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0)); 2953 2954 // Device functions queried using vkGetInstanceProcAddr should be non-NULL since this could be available for any attached 2955 // physical device. 2956 PFN_vkTrimCommandPoolKHR pfn_vkTrimCommandPool = inst.load("vkTrimCommandPoolKHR"); 2957 PFN_vkGetSwapchainStatusKHR pfn_vkGetSwapchainStatus = inst.load("vkGetSwapchainStatusKHR"); 2958 PFN_vkSetDeviceMemoryPriorityEXT pfn_vkSetDeviceMemoryPriority = inst.load("vkSetDeviceMemoryPriorityEXT"); 2959 handle_assert_has_value(pfn_vkTrimCommandPool); 2960 handle_assert_has_value(pfn_vkGetSwapchainStatus); 2961 handle_assert_has_value(pfn_vkSetDeviceMemoryPriority); 2962 2963 DeviceWrapper dev{inst}; 2964 dev.CheckCreate(phys_dev); 2965 2966 // Query again after create device to make sure the value returned by vkGetInstanceProcAddr did not change 2967 PFN_vkTrimCommandPoolKHR pfn_vkTrimCommandPool2 = inst.load("vkTrimCommandPoolKHR"); 2968 PFN_vkGetSwapchainStatusKHR pfn_vkGetSwapchainStatus2 = inst.load("vkGetSwapchainStatusKHR"); 2969 PFN_vkSetDeviceMemoryPriorityEXT pfn_vkSetDeviceMemoryPriority2 = inst.load("vkSetDeviceMemoryPriorityEXT"); 2970 ASSERT_EQ(pfn_vkTrimCommandPool, pfn_vkTrimCommandPool2); 2971 ASSERT_EQ(pfn_vkGetSwapchainStatus, pfn_vkGetSwapchainStatus2); 2972 ASSERT_EQ(pfn_vkSetDeviceMemoryPriority, pfn_vkSetDeviceMemoryPriority2); 2973 2974 // Make sure all the function pointers returned by vkGetDeviceProcAddr for non-enabled extensions are NULL 2975 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 2976 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 2977 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkSetDeviceMemoryPriorityEXT")); 2978 2979 // Even though the instance functions returned are non-NULL. They should not work if we haven't enabled the extensions. 2980 ASSERT_DEATH(pfn_vkTrimCommandPool(dev.dev, VK_NULL_HANDLE, 0), ""); 2981 ASSERT_DEATH(pfn_vkGetSwapchainStatus(dev.dev, VK_NULL_HANDLE), ""); 2982 ASSERT_DEATH(pfn_vkSetDeviceMemoryPriority(dev.dev, VK_NULL_HANDLE, 0.f), ""); 2983} 2984 2985TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) { 2986 FrameworkEnvironment env; 2987 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 2988 2989 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 2990 const char* enable_env_var = "ENABLE_ME"; 2991 const char* disable_env_var = "DISABLE_ME"; 2992 2993 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 2994 .set_name(implicit_layer_name) 2995 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1) 2996 .set_disable_environment(disable_env_var) 2997 .set_enable_environment(enable_env_var)), 2998 "implicit_wrap_layer_maint.json"); 2999 3000 auto layers = env.GetLayerProperties(1); 3001 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 3002 3003 // set enable env-var, layer should load 3004 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 3005 CheckLogForLayerString(env, implicit_layer_name, true); 3006 3007 InstWrapper inst{env.vulkan_functions}; 3008 inst.CheckCreate(); 3009 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3010 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1); 3011 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)); 3012 3013 DeviceWrapper dev{inst}; 3014 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME); 3015 dev.CheckCreate(phys_dev); 3016 3017 // Make sure only the appropriate function pointers are NULL as well 3018 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3019 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3020} 3021 3022TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) { 3023 FrameworkEnvironment env; 3024 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3025 3026 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3027 const char* enable_env_var = "ENABLE_ME"; 3028 const char* disable_env_var = "DISABLE_ME"; 3029 3030 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3031 .set_name(implicit_layer_name) 3032 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2) 3033 .set_disable_environment(disable_env_var) 3034 .set_enable_environment(enable_env_var)), 3035 "implicit_wrap_layer_pres.json"); 3036 3037 auto layers = env.GetLayerProperties(1); 3038 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 3039 3040 // set enable env-var, layer should load 3041 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 3042 CheckLogForLayerString(env, implicit_layer_name, true); 3043 3044 InstWrapper inst{env.vulkan_functions}; 3045 inst.CheckCreate(); 3046 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3047 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1); 3048 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)); 3049 3050 DeviceWrapper dev{inst}; 3051 dev.create_info.add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME); 3052 dev.CheckCreate(phys_dev); 3053 3054 // Make sure only the appropriate function pointers are NULL as well 3055 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3056 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3057} 3058 3059TEST(LayerExtensions, ImplicitBothDeviceExtensions) { 3060 FrameworkEnvironment env; 3061 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3062 3063 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3064 const char* enable_env_var = "ENABLE_ME"; 3065 const char* disable_env_var = "DISABLE_ME"; 3066 3067 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3068 .set_name(implicit_layer_name) 3069 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 3070 .set_disable_environment(disable_env_var) 3071 .set_enable_environment(enable_env_var)), 3072 "implicit_wrap_layer_both_dev.json"); 3073 3074 auto layers = env.GetLayerProperties(1); 3075 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name)); 3076 3077 // set enable env-var, layer should load 3078 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"}; 3079 CheckLogForLayerString(env, implicit_layer_name, true); 3080 3081 InstWrapper inst{env.vulkan_functions}; 3082 inst.CheckCreate(); 3083 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3084 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 2); 3085 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)); 3086 ASSERT_TRUE(string_eq(device_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)); 3087 3088 DeviceWrapper dev{inst}; 3089 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME).add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME); 3090 dev.CheckCreate(phys_dev); 3091 3092 // Make sure only the appropriate function pointers are NULL as well 3093 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3094 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3095} 3096 3097TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) { 3098 FrameworkEnvironment env; 3099 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3100 3101 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3102 env.add_explicit_layer( 3103 ManifestLayer{}.add_layer( 3104 ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)), 3105 "explicit_wrap_layer_no_ext.json"); 3106 3107 auto layers = env.GetLayerProperties(1); 3108 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 3109 3110 InstWrapper inst{env.vulkan_functions}; 3111 inst.create_info.add_layer(explicit_layer_name); 3112 inst.CheckCreate(); 3113 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3114 3115 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0)); 3116 ASSERT_NO_FATAL_FAILURE(inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 0)); 3117 3118 DeviceWrapper dev{inst}; 3119 dev.CheckCreate(phys_dev); 3120 3121 // Make sure all the function pointers are NULL as well 3122 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3123 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3124 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkSetDeviceMemoryPriorityEXT")); 3125} 3126 3127TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) { 3128 FrameworkEnvironment env; 3129 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3130 3131 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3132 env.add_explicit_layer( 3133 ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3134 .set_name(explicit_layer_name) 3135 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1) 3136 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 3137 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})), 3138 "explicit_wrap_layer_maint.json"); 3139 3140 auto layers = env.GetLayerProperties(1); 3141 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 3142 3143 InstWrapper inst{env.vulkan_functions}; 3144 inst.create_info.add_layer(explicit_layer_name); 3145 inst.CheckCreate(); 3146 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3147 3148 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0)); 3149 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 1); 3150 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)); 3151 3152 DeviceWrapper dev{inst}; 3153 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME); 3154 dev.CheckCreate(phys_dev); 3155 3156 // Make sure only the appropriate function pointers are NULL as well 3157 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3158 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3159} 3160 3161TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) { 3162 FrameworkEnvironment env; 3163 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3164 3165 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3166 env.add_explicit_layer( 3167 ManifestLayer{}.add_layer( 3168 ManifestLayer::LayerDescription{} 3169 .set_name(explicit_layer_name) 3170 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2) 3171 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 3172 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})), 3173 "explicit_wrap_layer_pres.json"); 3174 3175 auto layers = env.GetLayerProperties(1); 3176 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 3177 3178 InstWrapper inst{env.vulkan_functions}; 3179 inst.create_info.add_layer(explicit_layer_name); 3180 inst.CheckCreate(); 3181 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3182 3183 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0)); 3184 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 1); 3185 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)); 3186 3187 DeviceWrapper dev{inst}; 3188 dev.create_info.add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME); 3189 dev.CheckCreate(phys_dev); 3190 3191 // Make sure only the appropriate function pointers are NULL as well 3192 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3193 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR")); 3194} 3195 3196TEST(LayerExtensions, ExplicitBothDeviceExtensions) { 3197 FrameworkEnvironment env; 3198 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 3199 3200 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3201 env.add_explicit_layer( 3202 ManifestLayer{}.add_layer( 3203 ManifestLayer::LayerDescription{} 3204 .set_name(explicit_layer_name) 3205 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 3206 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 3207 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}}) 3208 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})), 3209 "explicit_wrap_layer_both_dev.json"); 3210 3211 auto layers = env.GetLayerProperties(1); 3212 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name)); 3213 3214 InstWrapper inst{env.vulkan_functions}; 3215 inst.create_info.add_layer(explicit_layer_name); 3216 inst.CheckCreate(); 3217 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 3218 handle_assert_has_value(phys_dev); 3219 3220 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0)); 3221 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 2); 3222 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)); 3223 ASSERT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)); 3224 3225 DeviceWrapper dev{inst}; 3226 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME).add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME); 3227 dev.CheckCreate(phys_dev); 3228 3229 // Make sure only the appropriate function pointers are NULL as well 3230 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR")); 3231 3232 PFN_vkGetSwapchainStatusKHR gipa_pfnGetSwapchainStatusKHR = inst.load("vkGetSwapchainStatusKHR"); 3233 PFN_vkGetSwapchainStatusKHR gdpa_pfnGetSwapchainStatusKHR = dev.load("vkGetSwapchainStatusKHR"); 3234 handle_assert_has_value(gipa_pfnGetSwapchainStatusKHR); 3235 handle_assert_has_value(gdpa_pfnGetSwapchainStatusKHR); 3236 3237 // Make sure both versions (from vkGetInstanceProcAddr and vkGetDeviceProcAddr) return the same value. 3238 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, gipa_pfnGetSwapchainStatusKHR(dev.dev, VK_NULL_HANDLE)); 3239 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, gdpa_pfnGetSwapchainStatusKHR(dev.dev, VK_NULL_HANDLE)); 3240} 3241 3242TEST(TestLayers, ExplicitlyEnableImplicitLayer) { 3243 FrameworkEnvironment env; 3244 uint32_t api_version = VK_API_VERSION_1_2; 3245 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version)) 3246 .set_icd_api_version(api_version) 3247 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish()); 3248 3249 const char* regular_layer_name = "VK_LAYER_TestLayer1"; 3250 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3251 .set_name(regular_layer_name) 3252 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3253 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 3254 .set_disable_environment("DisableMeIfYouCan")), 3255 "regular_test_layer.json"); 3256 { // 1.1 instance 3257 InstWrapper inst{env.vulkan_functions}; 3258 inst.create_info.add_layer(regular_layer_name); 3259 inst.create_info.set_api_version(1, 1, 0); 3260 inst.CheckCreate(); 3261 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3262 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3263 } 3264 { // 1.2 instance 3265 InstWrapper inst{env.vulkan_functions}; 3266 inst.create_info.add_layer(regular_layer_name); 3267 inst.create_info.set_api_version(1, 2, 0); 3268 inst.CheckCreate(); 3269 inst.GetActiveLayers(inst.GetPhysDev(), 1); 3270 } 3271} 3272 3273TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) { 3274 FrameworkEnvironment env; 3275 uint32_t api_version = VK_API_VERSION_1_2; 3276 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version)) 3277 .set_icd_api_version(api_version) 3278 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish()); 3279 3280 const char* regular_layer_name = "VK_LAYER_TestLayer1"; 3281 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3282 .set_name(regular_layer_name) 3283 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3284 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 3285 .set_disable_environment("DisableMeIfYouCan")), 3286 "regular_test_layer.json"); 3287 { // global functions 3288 auto layer_props = env.GetLayerProperties(1); 3289 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 3290 } 3291 { // 1.1 instance - should find the implicit layer 3292 InstWrapper inst{env.vulkan_functions}; 3293 inst.create_info.set_api_version(1, 1, 0); 3294 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 3295 inst.CheckCreate(); 3296 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3297 env.debug_log.clear(); 3298 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3299 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3300 } 3301 { // 1.2 instance -- instance layer should be found 3302 InstWrapper inst{env.vulkan_functions}; 3303 inst.create_info.set_api_version(1, 2, 0); 3304 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 3305 inst.CheckCreate(); 3306 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3307 env.debug_log.clear(); 3308 3309 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3310 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3311 } 3312} 3313 3314TEST(TestLayers, ImplicitLayerPre10APIVersion) { 3315 FrameworkEnvironment env; 3316 uint32_t api_version = VK_API_VERSION_1_2; 3317 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version)) 3318 .set_icd_api_version(api_version) 3319 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish()); 3320 3321 const char* regular_layer_name = "VK_LAYER_TestLayer1"; 3322 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3323 .set_name(regular_layer_name) 3324 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3325 .set_api_version(VK_MAKE_API_VERSION(0, 0, 1, 0)) 3326 .set_disable_environment("DisableMeIfYouCan")), 3327 "regular_test_layer.json"); 3328 { // global functions 3329 auto layer_props = env.GetLayerProperties(1); 3330 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name)); 3331 } 3332 { // 1.0 instance 3333 DebugUtilsLogger log; 3334 InstWrapper inst{env.vulkan_functions}; 3335 inst.create_info.set_api_version(1, 0, 0); 3336 FillDebugUtilsCreateDetails(inst.create_info, log); 3337 inst.CheckCreate(); 3338 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3339 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3340 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3341 } 3342 { // 1.1 instance 3343 DebugUtilsLogger log; 3344 InstWrapper inst{env.vulkan_functions}; 3345 inst.create_info.set_api_version(1, 1, 0); 3346 FillDebugUtilsCreateDetails(inst.create_info, log); 3347 inst.CheckCreate(); 3348 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3349 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3350 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3351 } 3352 { // 1.2 instance 3353 DebugUtilsLogger log; 3354 InstWrapper inst{env.vulkan_functions}; 3355 inst.create_info.set_api_version(1, 2, 0); 3356 FillDebugUtilsCreateDetails(inst.create_info, log); 3357 inst.CheckCreate(); 3358 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3359 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3360 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3361 } 3362 { // application sets its API version to 0 3363 DebugUtilsLogger log; 3364 InstWrapper inst{env.vulkan_functions}; 3365 inst.create_info.set_api_version(0); 3366 FillDebugUtilsCreateDetails(inst.create_info, log); 3367 inst.CheckCreate(); 3368 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name)); 3369 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 3370 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName)); 3371 } 3372} 3373 3374// Verify that VK_INSTANCE_LAYERS work. To test this, make sure that an explicit layer does not affect an instance until 3375// it is set with VK_INSTANCE_LAYERS 3376TEST(TestLayers, InstEnvironEnableExplicitLayer) { 3377 FrameworkEnvironment env; 3378 uint32_t api_version = VK_API_VERSION_1_2; 3379 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version)) 3380 .set_icd_api_version(api_version) 3381 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish()); 3382 3383 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 3384 env.add_explicit_layer( 3385 ManifestLayer{}.add_layer( 3386 ManifestLayer::LayerDescription{} 3387 .set_name(explicit_layer_name) 3388 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 3389 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 3390 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}}) 3391 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})), 3392 "explicit_wrap_layer_both_dev.json"); 3393 3394 // First, test an instance/device without the layer forced on. The extensions shouldn't be present and 3395 // the function pointers should be NULL. 3396 InstWrapper inst1{env.vulkan_functions}; 3397 inst1.CheckCreate(); 3398 VkPhysicalDevice phys_dev1 = inst1.GetPhysDev(); 3399 3400 ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0)); 3401 3402 // Create a device and query the function pointers 3403 DeviceWrapper dev1{inst1}; 3404 dev1.CheckCreate(phys_dev1); 3405 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolBefore = dev1.load("vkTrimCommandPoolKHR"); 3406 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusBefore = dev1.load("vkGetSwapchainStatusKHR"); 3407 handle_assert_null(pfn_TrimCommandPoolBefore); 3408 handle_assert_null(pfn_GetSwapchainStatusBefore); 3409 3410 // Now setup the instance layer 3411 EnvVarWrapper instance_layers_env_var{"VK_INSTANCE_LAYERS", explicit_layer_name}; 3412 3413 // Now, test an instance/device with the layer forced on. The extensions should be present and 3414 // the function pointers should be valid. 3415 InstWrapper inst2{env.vulkan_functions}; 3416 inst2.CheckCreate(); 3417 VkPhysicalDevice phys_dev2 = inst2.GetPhysDev(); 3418 3419 auto layer_extensions = inst2.EnumerateLayerDeviceExtensions(phys_dev2, explicit_layer_name, 2); 3420 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME)); 3421 ASSERT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)); 3422 3423 DeviceWrapper dev2{inst2}; 3424 dev2.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME) 3425 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME); 3426 dev2.CheckCreate(phys_dev2); 3427 3428 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev2.load("vkTrimCommandPoolKHR"); 3429 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev2.load("vkGetSwapchainStatusKHR"); 3430 handle_assert_has_value(pfn_TrimCommandPoolAfter); 3431 handle_assert_has_value(pfn_GetSwapchainStatusAfter); 3432 3433 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, pfn_GetSwapchainStatusAfter(dev2.dev, VK_NULL_HANDLE)); 3434} 3435 3436// Verify that VK_LOADER_LAYERS_ENABLE work. To test this, make sure that an explicit layer does not affect an instance until 3437// it is set with VK_LOADER_LAYERS_ENABLE 3438TEST(TestLayers, EnvironLayerEnableExplicitLayer) { 3439 FrameworkEnvironment env; 3440 uint32_t api_version = VK_API_VERSION_1_2; 3441 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version)) 3442 .set_icd_api_version(api_version) 3443 .add_physical_device(PhysicalDevice{}); 3444 3445 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 3446 const char* explicit_json_name_1 = "First_layer.json"; 3447 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3448 .set_name(explicit_layer_name_1) 3449 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3450 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3451 explicit_json_name_1); 3452 3453 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 3454 const char* explicit_json_name_2 = "Second_layer.json"; 3455 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3456 .set_name(explicit_layer_name_2) 3457 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3458 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3459 explicit_json_name_2); 3460 3461 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_second_test_layer"; 3462 const char* explicit_json_name_3 = "second_test_layer.json"; 3463 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3464 .set_name(explicit_layer_name_3) 3465 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3466 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3467 explicit_json_name_3); 3468 3469 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"}; 3470 3471 // First, test an instance/device without the layer forced on. 3472 InstWrapper inst1{env.vulkan_functions}; 3473 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 3474 inst1.CheckCreate(); 3475 3476 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3477 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3478 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3479 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3480 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3481 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3482 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3483 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3484 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3485 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3486 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3487 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3488 3489 // Now force on one layer with its full name 3490 // ------------------------------------------ 3491 env.debug_log.clear(); 3492 layers_enable_env_var.set_new_value(explicit_layer_name_1); 3493 3494 InstWrapper inst2{env.vulkan_functions}; 3495 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 3496 inst2.CheckCreate(); 3497 3498 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3499 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3500 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3501 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3502 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3503 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3504 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3505 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3506 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3507 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3508 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3509 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3510 3511 // Match prefix 3512 // ------------------------------------------ 3513 env.debug_log.clear(); 3514 layers_enable_env_var.set_new_value("VK_LAYER_LUNARG_*"); 3515 3516 InstWrapper inst3{env.vulkan_functions}; 3517 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 3518 inst3.CheckCreate(); 3519 3520 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3521 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3522 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3523 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3524 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3525 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3526 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3527 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3528 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3529 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3530 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3531 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3532 3533 // Match suffix 3534 // ------------------------------------------ 3535 env.debug_log.clear(); 3536 layers_enable_env_var.set_new_value("*Second_layer"); 3537 3538 InstWrapper inst4{env.vulkan_functions}; 3539 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 3540 inst4.CheckCreate(); 3541 3542 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3543 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3544 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3545 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3546 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3547 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3548 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3549 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3550 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3551 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3552 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3553 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3554 3555 // Match substring 3556 // ------------------------------------------ 3557 env.debug_log.clear(); 3558 layers_enable_env_var.set_new_value("*Second*"); 3559 3560 InstWrapper inst5{env.vulkan_functions}; 3561 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 3562 inst5.CheckCreate(); 3563 3564 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3565 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3566 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3567 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3568 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3569 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3570 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3571 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3572 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3573 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3574 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3575 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3576 3577 // Match all with star '*' 3578 // ------------------------------------------ 3579 env.debug_log.clear(); 3580 layers_enable_env_var.set_new_value("*"); 3581 3582 InstWrapper inst6{env.vulkan_functions}; 3583 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 3584 inst6.CheckCreate(); 3585 3586 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3587 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3588 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3589 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3590 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3591 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3592 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3593 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3594 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3595 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3596 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3597 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3598 3599 // Match all with special name 3600 // ------------------------------------------ 3601 env.debug_log.clear(); 3602 layers_enable_env_var.set_new_value("~all~"); 3603 3604 InstWrapper inst7{env.vulkan_functions}; 3605 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log); 3606 inst7.CheckCreate(); 3607 3608 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3609 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3610 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3611 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3612 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3613 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3614 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3615 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3616 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3617 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3618 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3619 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3620} 3621 3622// Verify that VK_LOADER_LAYERS_DISABLE work. To test this, make sure that an explicit layer does not affect an instance until 3623// it is set with VK_LOADER_LAYERS_DISABLE 3624TEST(TestLayers, EnvironLayerDisableExplicitLayer) { 3625 FrameworkEnvironment env; 3626 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 3627 .set_icd_api_version(VK_API_VERSION_1_2) 3628 .add_physical_device(PhysicalDevice{}); 3629 3630 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 3631 const char* explicit_json_name_1 = "First_layer.json"; 3632 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3633 .set_name(explicit_layer_name_1) 3634 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3635 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3636 explicit_json_name_1); 3637 3638 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 3639 const char* explicit_json_name_2 = "Second_layer.json"; 3640 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3641 .set_name(explicit_layer_name_2) 3642 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3643 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3644 explicit_json_name_2); 3645 3646 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer"; 3647 const char* explicit_json_name_3 = "Second_test_layer.json"; 3648 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3649 .set_name(explicit_layer_name_3) 3650 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3651 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3652 explicit_json_name_3); 3653 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 3654 3655 // First, test an instance/device without the layer forced on. 3656 InstWrapper inst1{env.vulkan_functions}; 3657 inst1.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3658 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 3659 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate()); 3660 3661 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3662 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3663 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3664 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3665 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3666 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3667 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3668 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3669 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3670 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3671 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3672 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3673 3674 // Now force on one layer with its full name 3675 // ------------------------------------------ 3676 env.debug_log.clear(); 3677 layers_disable_env_var.set_new_value(explicit_layer_name_1); 3678 3679 InstWrapper inst2{env.vulkan_functions}; 3680 inst2.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3681 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 3682 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3683 3684 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3685 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3686 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3687 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3688 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3689 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3690 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3691 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3692 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3693 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3694 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3695 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3696 3697 // Match prefix 3698 // ------------------------------------------ 3699 env.debug_log.clear(); 3700 layers_disable_env_var.set_new_value("VK_LAYER_LUNARG_*"); 3701 3702 InstWrapper inst3{env.vulkan_functions}; 3703 inst3.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3704 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 3705 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3706 3707 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3708 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3709 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3710 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3711 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3712 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3713 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3714 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3715 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3716 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3717 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3718 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3719 3720 // Match suffix 3721 // ------------------------------------------ 3722 env.debug_log.clear(); 3723 layers_disable_env_var.set_new_value("*Second_layer"); 3724 3725 InstWrapper inst4{env.vulkan_functions}; 3726 inst4.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3727 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 3728 ASSERT_NO_FATAL_FAILURE(inst4.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3729 3730 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3731 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3732 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3733 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3734 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3735 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3736 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3737 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3738 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3739 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3740 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3741 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3742 3743 // Match substring 3744 // ------------------------------------------ 3745 env.debug_log.clear(); 3746 layers_disable_env_var.set_new_value("*Second*"); 3747 3748 InstWrapper inst5{env.vulkan_functions}; 3749 inst5.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3750 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 3751 ASSERT_NO_FATAL_FAILURE(inst5.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3752 3753 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3754 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3755 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3756 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3757 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3758 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3759 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3760 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3761 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3762 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3763 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3764 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3765 3766 // Match all with star '*' 3767 // ------------------------------------------ 3768 env.debug_log.clear(); 3769 layers_disable_env_var.set_new_value("*"); 3770 3771 InstWrapper inst6{env.vulkan_functions}; 3772 inst6.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3773 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 3774 ASSERT_NO_FATAL_FAILURE(inst6.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3775 3776 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3777 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3778 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3779 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3780 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3781 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3782 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3783 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3784 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3785 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3786 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3787 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3788 3789 // Match all with special name 3790 // ------------------------------------------ 3791 env.debug_log.clear(); 3792 layers_disable_env_var.set_new_value("~all~"); 3793 3794 InstWrapper inst7{env.vulkan_functions}; 3795 inst7.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3796 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log); 3797 ASSERT_NO_FATAL_FAILURE(inst7.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3798 3799 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3800 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3801 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3802 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3803 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3804 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3805 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3806 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3807 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3808 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3809 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3810 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3811 3812 // Match explicit special name 3813 // ------------------------------------------ 3814 env.debug_log.clear(); 3815 layers_disable_env_var.set_new_value("~explicit~"); 3816 3817 InstWrapper inst8{env.vulkan_functions}; 3818 inst8.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3819 FillDebugUtilsCreateDetails(inst8.create_info, env.debug_log); 3820 ASSERT_NO_FATAL_FAILURE(inst8.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 3821 3822 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3823 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3824 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3825 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3826 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3827 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3828 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3829 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3830 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3831 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3832 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3833 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3834 3835 // No match implicit special name 3836 // ------------------------------------------ 3837 env.debug_log.clear(); 3838 layers_disable_env_var.set_new_value("~implicit~"); 3839 3840 InstWrapper inst9{env.vulkan_functions}; 3841 inst9.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3842 FillDebugUtilsCreateDetails(inst9.create_info, env.debug_log); 3843 ASSERT_NO_FATAL_FAILURE(inst9.CheckCreate()); 3844 3845 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3846 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3847 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3848 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3849 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3850 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3851 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3852 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3853 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3854 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3855 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3856 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3857} 3858 3859// Verify that VK_LOADER_LAYERS_ENABLE + VK_LOADER_LAYERS_DISABLE work.(results in the layer still being 3860// enabled) 3861TEST(TestLayers, EnvironLayerEnableDisableExplicitLayer) { 3862 FrameworkEnvironment env; 3863 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 3864 .set_icd_api_version(VK_API_VERSION_1_2); 3865 3866 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 3867 const char* explicit_json_name_1 = "First_layer.json"; 3868 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3869 .set_name(explicit_layer_name_1) 3870 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3871 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3872 explicit_json_name_1); 3873 3874 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 3875 const char* explicit_json_name_2 = "Second_layer.json"; 3876 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3877 .set_name(explicit_layer_name_2) 3878 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3879 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3880 explicit_json_name_2); 3881 3882 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer"; 3883 const char* explicit_json_name_3 = "Second_test_layer.json"; 3884 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 3885 .set_name(explicit_layer_name_3) 3886 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 3887 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 3888 explicit_json_name_3); 3889 3890 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"}; 3891 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 3892 3893 // First, test an instance/device without the layer forced on. 3894 InstWrapper inst1{env.vulkan_functions}; 3895 inst1.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 3896 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 3897 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate()); 3898 3899 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3900 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3901 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3902 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3903 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3904 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3905 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3906 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3907 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3908 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3909 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3910 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3911 3912 // Disable 2 but enable 1 3913 // ------------------------------------------ 3914 env.debug_log.clear(); 3915 layers_disable_env_var.set_new_value("*Second*"); 3916 layers_enable_env_var.set_new_value("*test_layer"); 3917 3918 InstWrapper inst2{env.vulkan_functions}; 3919 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 3920 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate()); 3921 3922 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3923 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3924 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3925 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3926 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3927 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3928 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3929 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3930 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3931 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3932 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3933 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3934 3935 // Disable all but enable 2 3936 // ------------------------------------------ 3937 env.debug_log.clear(); 3938 layers_disable_env_var.set_new_value("*"); 3939 layers_enable_env_var.set_new_value("*Second*"); 3940 3941 InstWrapper inst3{env.vulkan_functions}; 3942 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 3943 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate()); 3944 3945 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3946 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3947 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3948 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3949 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3950 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3951 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3952 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3953 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3954 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3955 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3956 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3957 3958 // Disable all but enable 2 3959 // ------------------------------------------ 3960 env.debug_log.clear(); 3961 layers_disable_env_var.set_new_value("~all~"); 3962 layers_enable_env_var.set_new_value("*Second*"); 3963 3964 InstWrapper inst4{env.vulkan_functions}; 3965 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log); 3966 ASSERT_NO_FATAL_FAILURE(inst4.CheckCreate()); 3967 3968 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3969 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3970 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3971 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3972 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3973 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3974 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3975 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3976 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 3977 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 3978 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 3979 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 3980 3981 // Disable explicit but enable 2 3982 // ------------------------------------------ 3983 env.debug_log.clear(); 3984 layers_disable_env_var.set_new_value("~explicit~"); 3985 layers_enable_env_var.set_new_value("*Second*"); 3986 3987 InstWrapper inst5{env.vulkan_functions}; 3988 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log); 3989 ASSERT_NO_FATAL_FAILURE(inst5.CheckCreate()); 3990 3991 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 3992 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 3993 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 3994 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 3995 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 3996 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 3997 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 3998 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 3999 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 4000 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 4001 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 4002 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 4003 4004 // Disable implicit but enable 2 (should still be everything) 4005 // ------------------------------------------ 4006 env.debug_log.clear(); 4007 layers_disable_env_var.set_new_value("~implicit~"); 4008 layers_enable_env_var.set_new_value("*Second*"); 4009 4010 InstWrapper inst6{env.vulkan_functions}; 4011 inst6.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 4012 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log); 4013 ASSERT_NO_FATAL_FAILURE(inst6.CheckCreate()); 4014 4015 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4016 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 4017 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4018 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4019 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 4020 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 4021 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 4022 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 4023 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 4024 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 4025 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 4026 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 4027 4028 // Disable explicit but enable all 4029 // ------------------------------------------ 4030 env.debug_log.clear(); 4031 layers_disable_env_var.set_new_value("~explicit~"); 4032 layers_enable_env_var.set_new_value("*"); 4033 4034 InstWrapper inst7{env.vulkan_functions}; 4035 inst7.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3); 4036 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log); 4037 ASSERT_NO_FATAL_FAILURE(inst7.CheckCreate()); 4038 4039 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4040 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 4041 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4042 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4043 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 4044 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 4045 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 4046 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 4047 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3)); 4048 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3)); 4049 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var")); 4050 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var")); 4051} 4052 4053// Verify that VK_INSTANCE_LAYERS + VK_LOADER_LAYERS_DISABLE work.(results in the layer still being 4054// enabled) 4055TEST(TestLayers, EnvironVkInstanceLayersAndDisableFilters) { 4056 FrameworkEnvironment env; 4057 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4058 .set_icd_api_version(VK_API_VERSION_1_2); 4059 4060 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 4061 const char* explicit_json_name_1 = "First_layer.json"; 4062 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4063 .set_name(explicit_layer_name_1) 4064 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4065 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 4066 explicit_json_name_1); 4067 4068 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer"; 4069 const char* explicit_json_name_2 = "Second_layer.json"; 4070 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4071 .set_name(explicit_layer_name_2) 4072 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4073 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 4074 explicit_json_name_2); 4075 4076 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS"}; 4077 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"}; 4078 4079 // First, test an instance/device without the layer forced on. 4080 InstWrapper inst1{env.vulkan_functions}; 4081 inst1.create_info.add_layer(explicit_layer_name_1); 4082 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log); 4083 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate()); 4084 4085 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4086 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 4087 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4088 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4089 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 4090 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 4091 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 4092 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 4093 4094 // Enable the non-default enabled layer with VK_INSTANCE_LAYERS 4095 // ------------------------------------------ 4096 env.debug_log.clear(); 4097 layers_enable_env_var.set_new_value(explicit_layer_name_2); 4098 4099 InstWrapper inst2{env.vulkan_functions}; 4100 inst2.create_info.add_layer(explicit_layer_name_1); 4101 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log); 4102 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate()); 4103 4104 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4105 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 4106 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4107 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4108 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 4109 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 4110 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 4111 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 4112 4113 // Try to disable all 4114 // ------------------------------------------ 4115 env.debug_log.clear(); 4116 layers_disable_env_var.set_new_value("*"); 4117 4118 InstWrapper inst3{env.vulkan_functions}; 4119 inst3.create_info.add_layer(explicit_layer_name_1); 4120 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 4121 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 4122 4123 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4124 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1)); 4125 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4126 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4127 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2)); 4128 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2)); 4129 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var")); 4130 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var")); 4131} 4132 4133// Verify that layers enabled through VK_INSTANCE_LAYERS which were not found get the proper error message 4134TEST(TestLayers, NonExistantLayerInVK_INSTANCE_LAYERS) { 4135 FrameworkEnvironment env; 4136 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 4137 4138 const char* layer_name = "VK_LAYER_test_layer"; 4139 env.add_explicit_layer( 4140 ManifestLayer{}.add_layer( 4141 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 4142 "test_layer.json"); 4143 4144 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", "VK_LAYER_I_dont_exist"}; 4145 { 4146 InstWrapper inst{env.vulkan_functions}; 4147 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4148 inst.CheckCreate(); 4149 4150 ASSERT_TRUE( 4151 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!")); 4152 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 4153 } 4154 // Make sure layers that do exist are loaded 4155 env.debug_log.clear(); 4156 layers_enable_env_var.add_to_list(layer_name); 4157 { 4158 InstWrapper inst{env.vulkan_functions}; 4159 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4160 inst.CheckCreate(); 4161 ASSERT_TRUE( 4162 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!")); 4163 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 4164 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name)); 4165 } 4166 // Make sure that if the layer appears twice in the env-var nothing bad happens 4167 env.debug_log.clear(); 4168 layers_enable_env_var.add_to_list("VK_LAYER_I_dont_exist"); 4169 { 4170 InstWrapper inst{env.vulkan_functions}; 4171 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4172 inst.CheckCreate(); 4173 ASSERT_TRUE( 4174 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!")); 4175 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 4176 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name)); 4177 } 4178} 4179 4180// Verify that if the same layer appears twice in VK_INSTANCE_LAYERS nothing bad happens 4181TEST(TestLayers, DuplicatesInEnvironVK_INSTANCE_LAYERS) { 4182 FrameworkEnvironment env; 4183 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); 4184 4185 const char* layer_name = "VK_LAYER_test_layer"; 4186 env.add_explicit_layer( 4187 ManifestLayer{}.add_layer( 4188 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 4189 "test_layer.json"); 4190 4191 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS"}; 4192 4193 layers_enable_env_var.add_to_list(layer_name); 4194 layers_enable_env_var.add_to_list(layer_name); 4195 4196 InstWrapper inst{env.vulkan_functions}; 4197 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4198 inst.CheckCreate(); 4199 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1); 4200 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name)); 4201} 4202 4203TEST(TestLayers, AppEnabledExplicitLayerFails) { 4204 FrameworkEnvironment env; 4205 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4206 .set_icd_api_version(VK_API_VERSION_1_2); 4207 4208 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 4209 const char* explicit_json_name_1 = "First_layer.json"; 4210 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4211 .set_name(explicit_layer_name_1) 4212 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4213 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))), 4214 explicit_json_name_1); 4215 4216 env.debug_log.clear(); 4217 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", explicit_layer_name_1}; 4218 4219 ASSERT_NO_FATAL_FAILURE(env.GetLayerProperties(0)); 4220 4221 InstWrapper inst3{env.vulkan_functions}; 4222 inst3.create_info.add_layer(explicit_layer_name_1); 4223 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log); 4224 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT)); 4225 4226 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4227 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4228 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4229 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4230} 4231 4232TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilter) { 4233 FrameworkEnvironment env; 4234 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4235 .set_icd_api_version(VK_API_VERSION_1_2); 4236 4237 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 4238 const char* explicit_json_name_1 = "First_layer.json"; 4239 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4240 .set_name(explicit_layer_name_1) 4241 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4242 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 4243 explicit_json_name_1); 4244 env.add_implicit_layer( 4245 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 4246 .set_name(lunarg_meta_layer_name) 4247 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 4248 .add_component_layer(explicit_layer_name_1) 4249 .set_disable_environment("DisableMeIfYouCan")), 4250 "meta_test_layer.json"); 4251 4252 env.debug_log.clear(); 4253 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", explicit_layer_name_1}; 4254 4255 auto layers = env.GetLayerProperties(1); 4256 EXPECT_TRUE(string_eq(lunarg_meta_layer_name, layers[0].layerName)); 4257 4258 { // both override layer and Disable env var 4259 InstWrapper inst{env.vulkan_functions}; 4260 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4261 inst.CheckCreate(); 4262 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4263 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4264 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4265 ASSERT_TRUE( 4266 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4267 } 4268 env.debug_log.clear(); 4269 { // Now try to enable the explicit layer as well 4270 InstWrapper inst{env.vulkan_functions}; 4271 inst.create_info.add_layer(explicit_layer_name_1); 4272 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4273 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT); 4274 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4275 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4276 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4277 ASSERT_TRUE( 4278 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4279 } 4280} 4281 4282TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer) { 4283 FrameworkEnvironment env; 4284 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4285 .set_icd_api_version(VK_API_VERSION_1_2); 4286 4287 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 4288 const char* explicit_json_name_1 = "First_layer.json"; 4289 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4290 .set_name(explicit_layer_name_1) 4291 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4292 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 4293 explicit_json_name_1); 4294 env.add_implicit_layer( 4295 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 4296 .set_name(lunarg_meta_layer_name) 4297 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 4298 .add_component_layer(explicit_layer_name_1) 4299 .set_disable_environment("DisableMeIfYouCan")), 4300 "meta_test_layer.json"); 4301 4302 env.debug_log.clear(); 4303 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", lunarg_meta_layer_name}; 4304 4305 auto layers = env.GetLayerProperties(1); 4306 EXPECT_TRUE(string_eq(explicit_layer_name_1, layers[0].layerName)); 4307 4308 { // both override layer and Disable env var 4309 InstWrapper inst{env.vulkan_functions}; 4310 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4311 inst.CheckCreate(); 4312 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4313 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4314 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4315 ASSERT_TRUE( 4316 env.debug_log.find_prefix_then_postfix(lunarg_meta_layer_name, "disabled because name matches filter of env var")); 4317 } 4318 env.debug_log.clear(); 4319 { // Now try to enable the explicit layer as well 4320 InstWrapper inst{env.vulkan_functions}; 4321 inst.create_info.add_layer(explicit_layer_name_1); 4322 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4323 inst.CheckCreate(); 4324 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4325 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4326 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4327 ASSERT_TRUE( 4328 env.debug_log.find_prefix_then_postfix(lunarg_meta_layer_name, "disabled because name matches filter of env var")); 4329 } 4330} 4331 4332TEST(TestLayers, OverrideBlacklistedLayerWithEnableFilter) { 4333 FrameworkEnvironment env; 4334 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4335 .set_icd_api_version(VK_API_VERSION_1_2); 4336 4337 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer"; 4338 const char* explicit_json_name_1 = "First_layer.json"; 4339 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4340 .set_name(explicit_layer_name_1) 4341 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4342 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))), 4343 explicit_json_name_1); 4344 env.add_implicit_layer( 4345 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{} 4346 .set_name(lunarg_meta_layer_name) 4347 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 4348 .add_blacklisted_layer(explicit_layer_name_1) 4349 .set_disable_environment("DisableMeIfYouCan")), 4350 "meta_test_layer.json"); 4351 4352 env.debug_log.clear(); 4353 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", explicit_layer_name_1}; 4354 4355 auto layers = env.GetLayerProperties(1); 4356 EXPECT_TRUE(string_eq(explicit_layer_name_1, layers[0].layerName)); 4357 { 4358 InstWrapper inst{env.vulkan_functions}; 4359 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4360 ASSERT_NO_FATAL_FAILURE(inst.CheckCreate()); 4361 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4362 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4363 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4364 ASSERT_FALSE( 4365 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4366 } 4367 env.debug_log.clear(); 4368 { // Try to enable a blacklisted layer 4369 InstWrapper inst{env.vulkan_functions}; 4370 inst.create_info.add_layer(explicit_layer_name_1); 4371 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log); 4372 ASSERT_NO_FATAL_FAILURE(inst.CheckCreate()); 4373 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1)); 4374 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1)); 4375 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var")); 4376 ASSERT_FALSE( 4377 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var")); 4378 } 4379} 4380 4381// Add a device layer, should not work 4382TEST(TestLayers, DoNotUseDeviceLayer) { 4383 FrameworkEnvironment env; 4384 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4385 .set_icd_api_version(VK_API_VERSION_1_2) 4386 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish()); 4387 4388 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 4389 env.add_explicit_layer( 4390 ManifestLayer{}.add_layer( 4391 ManifestLayer::LayerDescription{} 4392 .set_name(explicit_layer_name) 4393 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 4394 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 4395 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}}) 4396 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})), 4397 "explicit_wrap_layer_both_dev.json"); 4398 4399 // First, test an instance/device without the layer forced on. The extensions shouldn't be present and 4400 // the function pointers should be NULL. 4401 InstWrapper inst1{env.vulkan_functions}; 4402 inst1.CheckCreate(); 4403 VkPhysicalDevice phys_dev1 = inst1.GetPhysDev(); 4404 4405 // Make sure the extensions in the layer aren't present 4406 ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0)); 4407 4408 // Create a device and query the function pointers 4409 DeviceWrapper dev1{inst1}; 4410 dev1.CheckCreate(phys_dev1); 4411 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolBefore = dev1.load("vkTrimCommandPoolKHR"); 4412 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusBefore = dev1.load("vkGetSwapchainStatusKHR"); 4413 handle_assert_null(pfn_TrimCommandPoolBefore); 4414 handle_assert_null(pfn_GetSwapchainStatusBefore); 4415 4416 // Now, test an instance/device with the layer forced on. The extensions should be present and 4417 // the function pointers should be valid. 4418 InstWrapper inst2{env.vulkan_functions}; 4419 inst2.CheckCreate(); 4420 VkPhysicalDevice phys_dev2 = inst2.GetPhysDev(); 4421 4422 // Make sure the extensions in the layer aren't present 4423 ASSERT_NO_FATAL_FAILURE(inst2.EnumerateDeviceExtensions(phys_dev2, 0)); 4424 4425 DeviceWrapper dev2{inst2}; 4426 dev2.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME) 4427 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME) 4428 .add_layer(explicit_layer_name); 4429 dev2.CheckCreate(phys_dev2, VK_ERROR_EXTENSION_NOT_PRESENT); 4430 4431 DeviceWrapper dev3{inst2}; 4432 dev3.create_info.add_layer(explicit_layer_name); 4433 dev3.CheckCreate(phys_dev2); 4434 4435 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev3.load("vkTrimCommandPoolKHR"); 4436 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev3.load("vkGetSwapchainStatusKHR"); 4437 handle_assert_null(pfn_TrimCommandPoolAfter); 4438 handle_assert_null(pfn_GetSwapchainStatusAfter); 4439} 4440 4441// Make sure that a layer enabled as both an instance and device layer works properly. 4442TEST(TestLayers, InstanceAndDeviceLayer) { 4443 FrameworkEnvironment env; 4444 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4445 .set_icd_api_version(VK_API_VERSION_1_2) 4446 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish()); 4447 4448 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 4449 env.add_explicit_layer( 4450 ManifestLayer{}.add_layer( 4451 ManifestLayer::LayerDescription{} 4452 .set_name(explicit_layer_name) 4453 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3) 4454 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0)) 4455 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}}) 4456 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})), 4457 "explicit_wrap_layer_both_dev.json"); 4458 4459 InstWrapper inst{env.vulkan_functions}; 4460 inst.create_info.add_layer(explicit_layer_name); 4461 inst.CheckCreate(); 4462 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 4463 4464 DeviceWrapper dev{inst}; 4465 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME) 4466 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME) 4467 .add_layer(explicit_layer_name); 4468 dev.CheckCreate(phys_dev); 4469 4470 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev.load("vkTrimCommandPoolKHR"); 4471 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev.load("vkGetSwapchainStatusKHR"); 4472 handle_assert_has_value(pfn_TrimCommandPoolAfter); 4473 handle_assert_has_value(pfn_GetSwapchainStatusAfter); 4474 4475 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, pfn_GetSwapchainStatusAfter(dev.dev, VK_NULL_HANDLE)); 4476} 4477 4478// Make sure loader does not throw an error for a device layer that is not present 4479TEST(TestLayers, DeviceLayerNotPresent) { 4480 FrameworkEnvironment env; 4481 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2)) 4482 .set_icd_api_version(VK_API_VERSION_1_2) 4483 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish()); 4484 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects"; 4485 4486 InstWrapper inst{env.vulkan_functions}; 4487 inst.CheckCreate(); 4488 VkPhysicalDevice phys_dev = inst.GetPhysDev(); 4489 4490 DeviceWrapper dev{inst}; 4491 dev.create_info.add_layer(explicit_layer_name); 4492 dev.CheckCreate(phys_dev); 4493} 4494 4495TEST(LayerPhysDeviceMod, AddPhysicalDevices) { 4496 FrameworkEnvironment env; 4497 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4498 .set_name("VK_LAYER_LunarG_add_phys_dev") 4499 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4500 .set_api_version(VK_API_VERSION_1_1) 4501 .set_disable_environment("TEST_DISABLE_ADD_PHYS_DEV")), 4502 "test_layer_add.json"); 4503 4504 auto& layer = env.get_test_layer(0); 4505 layer.set_add_phys_devs(true); 4506 4507 for (uint32_t icd = 0; icd < 2; ++icd) { 4508 auto& cur_icd = 4509 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4510 VkPhysicalDeviceProperties properties{}; 4511 properties.apiVersion = VK_API_VERSION_1_2; 4512 properties.vendorID = 0x11000000 + (icd << 6); 4513 for (uint32_t dev = 0; dev < 3; ++dev) { 4514 properties.deviceID = properties.vendorID + dev; 4515 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4516 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4517#if defined(_WIN32) 4518 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4519#else 4520 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4521#endif 4522 cur_icd.add_physical_device({}); 4523 cur_icd.physical_devices.back().set_properties(properties); 4524 } 4525 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4526 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4527 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4528 } 4529 const uint32_t icd_devices = 6; 4530 4531 InstWrapper inst{env.vulkan_functions}; 4532 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4533 inst.CheckCreate(); 4534 4535 uint32_t dev_count = 0; 4536 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr)); 4537 ASSERT_GT(dev_count, icd_devices); 4538 4539 auto not_exp_physical_devices = std::vector<VkPhysicalDevice>(icd_devices); 4540 uint32_t returned_phys_dev_count = icd_devices; 4541 ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, not_exp_physical_devices.data())); 4542 ASSERT_EQ(icd_devices, returned_phys_dev_count); 4543 4544 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count); 4545 returned_phys_dev_count = dev_count; 4546 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data())); 4547 ASSERT_EQ(dev_count, returned_phys_dev_count); 4548 4549 uint32_t diff_count = dev_count - icd_devices; 4550 uint32_t found_incomplete = 0; 4551 uint32_t found_added_count = 0; 4552 for (uint32_t dev = 0; dev < dev_count; ++dev) { 4553 VkPhysicalDeviceProperties props{}; 4554 inst->vkGetPhysicalDeviceProperties(physical_devices[dev], &props); 4555 if (string_eq(props.deviceName, "physdev_added_xx")) { 4556 found_added_count++; 4557 } 4558 for (uint32_t incomp = 0; incomp < icd_devices; ++incomp) { 4559 if (not_exp_physical_devices[incomp] == physical_devices[dev]) { 4560 found_incomplete++; 4561 break; 4562 } 4563 } 4564 } 4565 4566 // We should have added the number of diff items, and the incomplete count should match the number of 4567 // original physical devices. 4568 ASSERT_EQ(found_added_count, diff_count); 4569 ASSERT_EQ(found_incomplete, icd_devices); 4570} 4571 4572TEST(LayerPhysDeviceMod, RemovePhysicalDevices) { 4573 FrameworkEnvironment env; 4574 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4575 .set_name("VK_LAYER_LunarG_remove_phys_dev") 4576 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4577 .set_api_version(VK_API_VERSION_1_1) 4578 .set_disable_environment("TEST_DISABLE_REMOVE_PHYS_DEV")), 4579 "test_layer_remove.json"); 4580 4581 auto& layer = env.get_test_layer(0); 4582 layer.set_remove_phys_devs(true); 4583 4584 for (uint32_t icd = 0; icd < 2; ++icd) { 4585 auto& cur_icd = 4586 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4587 VkPhysicalDeviceProperties properties{}; 4588 properties.apiVersion = VK_API_VERSION_1_2; 4589 properties.vendorID = 0x11000000 + (icd << 6); 4590 for (uint32_t dev = 0; dev < 3; ++dev) { 4591 properties.deviceID = properties.vendorID + dev; 4592 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4593 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4594#if defined(_WIN32) 4595 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4596#else 4597 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4598#endif 4599 cur_icd.add_physical_device({}); 4600 cur_icd.physical_devices.back().set_properties(properties); 4601 } 4602 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4603 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4604 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4605 } 4606 const uint32_t icd_devices = 6; 4607 4608 InstWrapper inst{env.vulkan_functions}; 4609 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4610 inst.CheckCreate(); 4611 4612 uint32_t dev_count = 0; 4613 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr)); 4614 ASSERT_LT(dev_count, icd_devices); 4615 4616 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count); 4617 uint32_t returned_phys_dev_count = dev_count; 4618 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data())); 4619 ASSERT_EQ(dev_count, returned_phys_dev_count); 4620} 4621 4622TEST(LayerPhysDeviceMod, ReorderPhysicalDevices) { 4623 FrameworkEnvironment env; 4624 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4625 .set_name("VK_LAYER_LunarG_reorder_phys_dev") 4626 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4627 .set_api_version(VK_API_VERSION_1_1) 4628 .set_disable_environment("TEST_DISABLE_REORDER_PHYS_DEV")), 4629 "test_layer_reorder.json"); 4630 4631 auto& layer = env.get_test_layer(0); 4632 layer.set_reorder_phys_devs(true); 4633 4634 for (uint32_t icd = 0; icd < 2; ++icd) { 4635 auto& cur_icd = 4636 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4637 VkPhysicalDeviceProperties properties{}; 4638 properties.apiVersion = VK_API_VERSION_1_2; 4639 properties.vendorID = 0x11000000 + (icd << 6); 4640 for (uint32_t dev = 0; dev < 3; ++dev) { 4641 properties.deviceID = properties.vendorID + dev; 4642 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4643 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4644#if defined(_WIN32) 4645 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4646#else 4647 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4648#endif 4649 cur_icd.add_physical_device({}); 4650 cur_icd.physical_devices.back().set_properties(properties); 4651 } 4652 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4653 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4654 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4655 } 4656 const uint32_t icd_devices = 6; 4657 4658 InstWrapper inst{env.vulkan_functions}; 4659 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4660 inst.CheckCreate(); 4661 4662 uint32_t dev_count = 0; 4663 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr)); 4664 ASSERT_EQ(dev_count, icd_devices); 4665 4666 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count); 4667 uint32_t returned_phys_dev_count = dev_count; 4668 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data())); 4669 ASSERT_EQ(dev_count, returned_phys_dev_count); 4670} 4671 4672TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) { 4673 FrameworkEnvironment env; 4674 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4675 .set_name("VK_LAYER_LunarG_all_phys_dev") 4676 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4677 .set_api_version(VK_API_VERSION_1_1) 4678 .set_disable_environment("TEST_DISABLE_ALL_PHYS_DEV")), 4679 "test_layer_all.json"); 4680 4681 auto& layer = env.get_test_layer(0); 4682 layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true); 4683 4684 for (uint32_t icd = 0; icd < 2; ++icd) { 4685 auto& cur_icd = 4686 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4687 VkPhysicalDeviceProperties properties{}; 4688 properties.apiVersion = VK_API_VERSION_1_2; 4689 properties.vendorID = 0x11000000 + (icd << 6); 4690 for (uint32_t dev = 0; dev < 3; ++dev) { 4691 properties.deviceID = properties.vendorID + dev; 4692 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4693 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4694#if defined(_WIN32) 4695 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4696#else 4697 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4698#endif 4699 cur_icd.add_physical_device({}); 4700 cur_icd.physical_devices.back().set_properties(properties); 4701 } 4702 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4703 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4704 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4705 } 4706 const uint32_t icd_devices = 6; 4707 4708 InstWrapper inst{env.vulkan_functions}; 4709 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4710 inst.CheckCreate(); 4711 4712 uint32_t dev_count = 0; 4713 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr)); 4714 ASSERT_GT(dev_count, icd_devices); 4715 4716 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count); 4717 uint32_t returned_phys_dev_count = dev_count; 4718 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data())); 4719 ASSERT_EQ(dev_count, returned_phys_dev_count); 4720 4721 uint32_t found_added_count = 0; 4722 for (uint32_t dev = 0; dev < dev_count; ++dev) { 4723 VkPhysicalDeviceProperties props{}; 4724 inst->vkGetPhysicalDeviceProperties(physical_devices[dev], &props); 4725 if (string_eq(props.deviceName, "physdev_added_xx")) { 4726 found_added_count++; 4727 } 4728 } 4729 4730 // Should see 2 removed, but 3 added so a diff count of 1 4731 uint32_t diff_count = dev_count - icd_devices; 4732 ASSERT_EQ(1U, diff_count); 4733 ASSERT_EQ(found_added_count, 3U); 4734} 4735 4736bool GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDeviceGroupProperties b) { 4737 if (a.physicalDeviceCount != b.physicalDeviceCount) { 4738 return false; 4739 } 4740 for (uint32_t dev = 0; dev < a.physicalDeviceCount; ++dev) { 4741 if (a.physicalDevices[dev] != b.physicalDevices[dev]) { 4742 return false; 4743 } 4744 } 4745 return true; 4746} 4747 4748TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups) { 4749 FrameworkEnvironment env; 4750 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4751 .set_name("VK_LAYER_LunarG_add_phys_dev") 4752 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4753 .set_api_version(VK_API_VERSION_1_1) 4754 .set_disable_environment("TEST_DISABLE_ADD_PHYS_DEV")), 4755 "test_layer_remove.json"); 4756 4757 auto& layer = env.get_test_layer(0); 4758 layer.set_add_phys_devs(true); 4759 4760 for (uint32_t icd = 0; icd < 2; ++icd) { 4761 auto& cur_icd = 4762 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4763 VkPhysicalDeviceProperties properties{}; 4764 properties.apiVersion = VK_API_VERSION_1_2; 4765 properties.vendorID = 0x11000000 + (icd << 6); 4766 for (uint32_t dev = 0; dev < 3; ++dev) { 4767 properties.deviceID = properties.vendorID + dev; 4768 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4769 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4770#if defined(_WIN32) 4771 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4772#else 4773 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4774#endif 4775 cur_icd.add_physical_device({}); 4776 cur_icd.physical_devices.back().set_properties(properties); 4777 } 4778 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4779 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4780 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4781 } 4782 const uint32_t icd_groups = 4; 4783 4784 InstWrapper inst{env.vulkan_functions}; 4785 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4786 inst.CheckCreate(); 4787 4788 uint32_t grp_count = 0; 4789 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr)); 4790 ASSERT_GT(grp_count, icd_groups); 4791 4792 auto not_exp_phys_dev_groups = 4793 std::vector<VkPhysicalDeviceGroupProperties>(icd_groups, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); 4794 4795 uint32_t returned_group_count = icd_groups; 4796 ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, not_exp_phys_dev_groups.data())); 4797 ASSERT_EQ(icd_groups, returned_group_count); 4798 4799 auto phys_dev_groups = 4800 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); 4801 4802 returned_group_count = grp_count; 4803 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data())); 4804 ASSERT_EQ(grp_count, returned_group_count); 4805 4806 uint32_t diff_count = grp_count - icd_groups; 4807 uint32_t found_incomplete = 0; 4808 uint32_t found_added_count = 0; 4809 for (uint32_t grp = 0; grp < grp_count; ++grp) { 4810 // Shortcut, only groups with 1 device could be added in the newly added count 4811 if (1 == phys_dev_groups[grp].physicalDeviceCount) { 4812 for (uint32_t dev = 0; dev < phys_dev_groups[grp].physicalDeviceCount; ++dev) { 4813 VkPhysicalDeviceProperties props{}; 4814 inst->vkGetPhysicalDeviceProperties(phys_dev_groups[grp].physicalDevices[dev], &props); 4815 if (string_eq(props.deviceName, "physdev_added_xx")) { 4816 found_added_count++; 4817 } 4818 } 4819 } 4820 for (uint32_t incomp = 0; incomp < icd_groups; ++incomp) { 4821 if (GroupsAreTheSame(not_exp_phys_dev_groups[incomp], phys_dev_groups[grp])) { 4822 found_incomplete++; 4823 break; 4824 } 4825 } 4826 } 4827 4828 // We should have added the number of diff items, and the incomplete count should match the number of 4829 // original physical devices. 4830 ASSERT_EQ(found_added_count, diff_count); 4831 ASSERT_EQ(found_incomplete, icd_groups); 4832} 4833 4834TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) { 4835 FrameworkEnvironment env; 4836 EnvVarWrapper disable_linux_sort("VK_LOADER_DISABLE_SELECT", "1"); 4837 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4838 .set_name("VK_LAYER_LunarG_remove_phys_dev") 4839 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4840 .set_api_version(VK_API_VERSION_1_1) 4841 .set_disable_environment("TEST_DISABLE_REMOVE_PHYS_DEV")), 4842 "test_layer_remove.json"); 4843 4844 auto& layer = env.get_test_layer(0); 4845 layer.set_remove_phys_devs(true); 4846 4847 for (uint32_t icd = 0; icd < 2; ++icd) { 4848 auto& cur_icd = 4849 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4850 VkPhysicalDeviceProperties properties{}; 4851 properties.apiVersion = VK_API_VERSION_1_2; 4852 properties.vendorID = 0x11000000 + (icd << 6); 4853 for (uint32_t dev = 0; dev < 3; ++dev) { 4854 properties.deviceID = properties.vendorID + dev; 4855 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4856 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4857#if defined(_WIN32) 4858 strncpy_s(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4859#else 4860 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4861#endif 4862 cur_icd.add_physical_device({}); 4863 cur_icd.physical_devices.back().set_properties(properties); 4864 } 4865 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4866 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4867 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4868 } 4869 const uint32_t icd_groups = 3; 4870 4871 InstWrapper inst{env.vulkan_functions}; 4872 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4873 inst.CheckCreate(); 4874 4875 uint32_t grp_count = 0; 4876 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr)); 4877 ASSERT_EQ(grp_count, icd_groups); 4878 4879 auto phys_dev_groups = 4880 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); 4881 4882 uint32_t returned_group_count = grp_count; 4883 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data())); 4884 ASSERT_EQ(grp_count, returned_group_count); 4885} 4886 4887TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) { 4888 FrameworkEnvironment env; 4889 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4890 .set_name("VK_LAYER_LunarG_reorder_phys_dev") 4891 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4892 .set_api_version(VK_API_VERSION_1_1) 4893 .set_disable_environment("TEST_DISABLE_REORDER_PHYS_DEV")), 4894 "test_layer_reorder.json"); 4895 4896 auto& layer = env.get_test_layer(0); 4897 layer.set_reorder_phys_devs(true); 4898 4899 for (uint32_t icd = 0; icd < 2; ++icd) { 4900 auto& cur_icd = 4901 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4902 VkPhysicalDeviceProperties properties{}; 4903 properties.apiVersion = VK_API_VERSION_1_2; 4904 properties.vendorID = 0x11000000 + (icd << 6); 4905 for (uint32_t dev = 0; dev < 3; ++dev) { 4906 properties.deviceID = properties.vendorID + dev; 4907 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4908 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4909#if defined(_WIN32) 4910 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4911#else 4912 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4913#endif 4914 cur_icd.add_physical_device({}); 4915 cur_icd.physical_devices.back().set_properties(properties); 4916 } 4917 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4918 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]); 4919 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]); 4920 } 4921 const uint32_t icd_groups = 4; 4922 4923 InstWrapper inst{env.vulkan_functions}; 4924 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4925 inst.CheckCreate(); 4926 4927 uint32_t grp_count = 0; 4928 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr)); 4929 ASSERT_EQ(grp_count, icd_groups); 4930 4931 auto phys_dev_groups = 4932 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); 4933 4934 uint32_t returned_group_count = grp_count; 4935 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data())); 4936 ASSERT_EQ(grp_count, returned_group_count); 4937} 4938 4939TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) { 4940 FrameworkEnvironment env; 4941 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 4942 .set_name("VK_LAYER_LunarG_all_phys_dev") 4943 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 4944 .set_api_version(VK_API_VERSION_1_1) 4945 .set_disable_environment("TEST_DISABLE_ALL_PHYS_DEV")), 4946 "test_layer_all.json"); 4947 4948 auto& layer = env.get_test_layer(0); 4949 layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true); 4950 4951 for (uint32_t icd = 0; icd < 2; ++icd) { 4952 auto& cur_icd = 4953 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2); 4954 VkPhysicalDeviceProperties properties{}; 4955 properties.apiVersion = VK_API_VERSION_1_2; 4956 properties.vendorID = 0x11000000 + (icd << 6); 4957 for (uint32_t dev = 0; dev < 3; ++dev) { 4958 properties.deviceID = properties.vendorID + dev; 4959 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 4960 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev); 4961#if defined(_WIN32) 4962 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1); 4963#else 4964 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); 4965#endif 4966 cur_icd.add_physical_device({}); 4967 cur_icd.physical_devices.back().set_properties(properties); 4968 } 4969 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]); 4970 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[1]); 4971 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[2]); 4972 } 4973 const uint32_t icd_groups = 4; 4974 4975 InstWrapper inst{env.vulkan_functions}; 4976 inst.create_info.set_api_version(VK_API_VERSION_1_1); 4977 inst.CheckCreate(); 4978 4979 uint32_t grp_count = 0; 4980 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr)); 4981 ASSERT_GT(grp_count, icd_groups); 4982 4983 auto phys_dev_groups = 4984 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); 4985 4986 uint32_t returned_group_count = grp_count; 4987 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data())); 4988 ASSERT_EQ(grp_count, returned_group_count); 4989 4990 uint32_t diff_count = grp_count - icd_groups; 4991 uint32_t found_added_count = 0; 4992 for (uint32_t grp = 0; grp < grp_count; ++grp) { 4993 // Shortcut, only groups with 1 device could be added in the newly added count 4994 if (1 == phys_dev_groups[grp].physicalDeviceCount) { 4995 for (uint32_t dev = 0; dev < phys_dev_groups[grp].physicalDeviceCount; ++dev) { 4996 VkPhysicalDeviceProperties props{}; 4997 inst->vkGetPhysicalDeviceProperties(phys_dev_groups[grp].physicalDevices[dev], &props); 4998 if (string_eq(props.deviceName, "physdev_added_xx")) { 4999 found_added_count++; 5000 } 5001 } 5002 } 5003 } 5004 5005 // Should see 2 devices removed which should result in 1 group removed and since 3 5006 // devices were added we should have 3 new groups. So we should have a diff of 2 5007 // groups and 3 new groups 5008 ASSERT_EQ(2U, diff_count); 5009 ASSERT_EQ(found_added_count, 3U); 5010} 5011 5012TEST(TestLayers, AllowFilterWithExplicitLayer) { 5013 FrameworkEnvironment env; 5014 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({}); 5015 const char* layer_name = "VK_LAYER_test_layer"; 5016 env.add_explicit_layer( 5017 ManifestLayer{}.add_layer( 5018 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)), 5019 "test_layer_all.json"); 5020 5021 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name}; 5022 { 5023 InstWrapper inst{env.vulkan_functions}; 5024 inst.CheckCreate(); 5025 5026 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5027 } 5028 { 5029 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5030 5031 InstWrapper inst{env.vulkan_functions}; 5032 inst.CheckCreate(); 5033 5034 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5035 } 5036 { 5037 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5038 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5039 5040 InstWrapper inst{env.vulkan_functions}; 5041 inst.CheckCreate(); 5042 5043 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5044 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5045 } 5046 { 5047 InstWrapper inst{env.vulkan_functions}; 5048 inst.create_info.add_layer(layer_name); 5049 inst.CheckCreate(); 5050 5051 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5052 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5053 } 5054 { 5055 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5056 LoaderSettingsLayerConfiguration{} 5057 .set_name(layer_name) 5058 .set_control("on") 5059 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5060 .set_treat_as_implicit_manifest(false))); 5061 env.update_loader_settings(env.loader_settings); 5062 5063 InstWrapper inst{env.vulkan_functions}; 5064 inst.CheckCreate(); 5065 5066 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5067 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5068 } 5069 { 5070 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5071 env.update_loader_settings(env.loader_settings); 5072 5073 InstWrapper inst{env.vulkan_functions}; 5074 inst.CheckCreate(); 5075 5076 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5077 } 5078 { 5079 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5080 env.update_loader_settings(env.loader_settings); 5081 5082 InstWrapper inst{env.vulkan_functions}; 5083 inst.CheckCreate(); 5084 5085 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5086 } 5087} 5088 5089TEST(TestLayers, AllowFilterWithImplicitLayer) { 5090 FrameworkEnvironment env; 5091 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({}); 5092 const char* layer_name = "VK_LAYER_test_layer"; 5093 const char* disable_env_var = "TEST_DISABLE_ENV_VAR"; 5094 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 5095 .set_name(layer_name) 5096 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 5097 .set_disable_environment(disable_env_var)), 5098 "test_layer_all.json"); 5099 5100 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name}; 5101 5102 { 5103 InstWrapper inst{env.vulkan_functions}; 5104 inst.CheckCreate(); 5105 5106 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5107 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5108 } 5109 { 5110 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5111 5112 InstWrapper inst{env.vulkan_functions}; 5113 inst.CheckCreate(); 5114 5115 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5116 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5117 } 5118 { 5119 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5120 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5121 5122 InstWrapper inst{env.vulkan_functions}; 5123 inst.CheckCreate(); 5124 5125 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5126 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5127 } 5128 { 5129 InstWrapper inst{env.vulkan_functions}; 5130 inst.create_info.add_layer(layer_name); 5131 inst.CheckCreate(); 5132 5133 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5134 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5135 } 5136 { 5137 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5138 LoaderSettingsLayerConfiguration{} 5139 .set_name(layer_name) 5140 .set_control("on") 5141 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5142 .set_treat_as_implicit_manifest(true))); 5143 env.update_loader_settings(env.loader_settings); 5144 5145 InstWrapper inst{env.vulkan_functions}; 5146 inst.CheckCreate(); 5147 5148 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5149 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5150 } 5151 { 5152 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5153 env.update_loader_settings(env.loader_settings); 5154 5155 InstWrapper inst{env.vulkan_functions}; 5156 inst.CheckCreate(); 5157 5158 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5159 } 5160 { 5161 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5162 env.update_loader_settings(env.loader_settings); 5163 5164 InstWrapper inst{env.vulkan_functions}; 5165 inst.CheckCreate(); 5166 5167 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5168 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5169 } 5170 5171 env.remove_loader_settings(); 5172 5173 // Set the disable_environment variable 5174 EnvVarWrapper set_disable_env_var{disable_env_var, "1"}; 5175 5176 { 5177 InstWrapper inst{env.vulkan_functions}; 5178 inst.CheckCreate(); 5179 5180 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5181 } 5182 { 5183 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5184 5185 InstWrapper inst{env.vulkan_functions}; 5186 inst.CheckCreate(); 5187 5188 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5189 } 5190 { 5191 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5192 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5193 5194 InstWrapper inst{env.vulkan_functions}; 5195 inst.CheckCreate(); 5196 5197 // layer's disable_environment takes priority 5198 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5199 } 5200 { 5201 InstWrapper inst{env.vulkan_functions}; 5202 inst.create_info.add_layer(layer_name); 5203 inst.CheckCreate(); 5204 5205 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5206 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5207 } 5208 { 5209 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5210 LoaderSettingsLayerConfiguration{} 5211 .set_name(layer_name) 5212 .set_control("on") 5213 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5214 .set_treat_as_implicit_manifest(true))); 5215 env.update_loader_settings(env.loader_settings); 5216 5217 InstWrapper inst{env.vulkan_functions}; 5218 inst.CheckCreate(); 5219 5220 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5221 } 5222 { 5223 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5224 env.update_loader_settings(env.loader_settings); 5225 5226 InstWrapper inst{env.vulkan_functions}; 5227 inst.CheckCreate(); 5228 5229 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5230 } 5231 { 5232 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5233 env.update_loader_settings(env.loader_settings); 5234 5235 InstWrapper inst{env.vulkan_functions}; 5236 inst.CheckCreate(); 5237 5238 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5239 } 5240} 5241 5242TEST(TestLayers, AllowFilterWithConditionallyImlicitLayer) { 5243 FrameworkEnvironment env; 5244 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({}); 5245 const char* layer_name = "VK_LAYER_test_layer"; 5246 const char* enable_env_var = "TEST_ENABLE_ENV_VAR"; 5247 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 5248 .set_name(layer_name) 5249 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 5250 .set_disable_environment("TEST_DISABLE_ENV_VAR") 5251 .set_enable_environment(enable_env_var)), 5252 "test_layer_all.json"); 5253 5254 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name}; 5255 5256 { 5257 InstWrapper inst{env.vulkan_functions}; 5258 inst.CheckCreate(); 5259 5260 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5261 } 5262 { 5263 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5264 5265 InstWrapper inst{env.vulkan_functions}; 5266 inst.CheckCreate(); 5267 5268 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5269 } 5270 { 5271 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5272 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5273 5274 InstWrapper inst{env.vulkan_functions}; 5275 inst.CheckCreate(); 5276 5277 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5278 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5279 } 5280 { 5281 InstWrapper inst{env.vulkan_functions}; 5282 inst.create_info.add_layer(layer_name); 5283 inst.CheckCreate(); 5284 5285 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5286 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5287 } 5288 { 5289 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5290 LoaderSettingsLayerConfiguration{} 5291 .set_name(layer_name) 5292 .set_control("on") 5293 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5294 .set_treat_as_implicit_manifest(true))); 5295 env.update_loader_settings(env.loader_settings); 5296 5297 InstWrapper inst{env.vulkan_functions}; 5298 inst.CheckCreate(); 5299 5300 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5301 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5302 } 5303 { 5304 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5305 env.update_loader_settings(env.loader_settings); 5306 5307 InstWrapper inst{env.vulkan_functions}; 5308 inst.CheckCreate(); 5309 5310 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5311 } 5312 { 5313 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5314 env.update_loader_settings(env.loader_settings); 5315 5316 InstWrapper inst{env.vulkan_functions}; 5317 inst.CheckCreate(); 5318 5319 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5320 } 5321 5322 env.remove_loader_settings(); 5323 5324 // Repeate the above tests but with the enable_environment variable set 5325 EnvVarWrapper set_enable_env_var{enable_env_var, "1"}; 5326 5327 { 5328 InstWrapper inst{env.vulkan_functions}; 5329 inst.CheckCreate(); 5330 5331 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5332 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5333 } 5334 { 5335 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5336 5337 InstWrapper inst{env.vulkan_functions}; 5338 inst.CheckCreate(); 5339 5340 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5341 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5342 } 5343 { 5344 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5345 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5346 5347 InstWrapper inst{env.vulkan_functions}; 5348 inst.CheckCreate(); 5349 5350 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5351 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5352 } 5353 { 5354 InstWrapper inst{env.vulkan_functions}; 5355 inst.create_info.add_layer(layer_name); 5356 inst.CheckCreate(); 5357 5358 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5359 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5360 } 5361 { 5362 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5363 LoaderSettingsLayerConfiguration{} 5364 .set_name(layer_name) 5365 .set_control("on") 5366 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5367 .set_treat_as_implicit_manifest(true))); 5368 env.update_loader_settings(env.loader_settings); 5369 5370 InstWrapper inst{env.vulkan_functions}; 5371 inst.CheckCreate(); 5372 5373 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5374 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5375 } 5376 { 5377 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5378 env.update_loader_settings(env.loader_settings); 5379 5380 InstWrapper inst{env.vulkan_functions}; 5381 inst.CheckCreate(); 5382 5383 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5384 } 5385 { 5386 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5387 env.update_loader_settings(env.loader_settings); 5388 5389 InstWrapper inst{env.vulkan_functions}; 5390 inst.CheckCreate(); 5391 5392 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5393 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5394 } 5395} 5396 5397TEST(TestLayers, AllowFilterWithConditionallyImlicitLayerWithOverrideLayer) { 5398 FrameworkEnvironment env; 5399 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({}); 5400 const char* layer_name = "VK_LAYER_test_layer"; 5401 const char* enable_env_var = "TEST_ENABLE_ENV_VAR"; 5402 env.add_implicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} 5403 .set_name(layer_name) 5404 .set_api_version(VK_API_VERSION_1_1) 5405 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) 5406 .set_disable_environment("TEST_DISABLE_ENV_VAR") 5407 .set_enable_environment(enable_env_var)), 5408 "test_layer_all.json"} 5409 .set_discovery_type(ManifestDiscoveryType::override_folder)); 5410 5411 env.add_implicit_layer( 5412 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer( 5413 ManifestLayer::LayerDescription{} 5414 .set_name(lunarg_meta_layer_name) 5415 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)) 5416 .add_component_layer(layer_name) 5417 .set_disable_environment("DisableMeIfYouCan") 5418 .add_override_path(fs::make_native(env.get_folder(ManifestLocation::override_layer).location().str()))), 5419 "meta_test_layer.json"); 5420 5421 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name}; 5422 5423 { 5424 InstWrapper inst{env.vulkan_functions}; 5425 inst.CheckCreate(); 5426 5427 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2); 5428 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5429 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name)); 5430 } 5431 { 5432 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5433 5434 InstWrapper inst{env.vulkan_functions}; 5435 inst.CheckCreate(); 5436 5437 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2); 5438 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5439 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name)); 5440 } 5441 { 5442 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name}; 5443 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name}; 5444 5445 InstWrapper inst{env.vulkan_functions}; 5446 inst.CheckCreate(); 5447 5448 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2); 5449 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5450 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name)); 5451 } 5452 { 5453 InstWrapper inst{env.vulkan_functions}; 5454 inst.create_info.add_layer(layer_name); 5455 inst.CheckCreate(); 5456 5457 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2); 5458 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5459 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name)); 5460 } 5461 { 5462 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration( 5463 LoaderSettingsLayerConfiguration{} 5464 .set_name(layer_name) 5465 .set_control("on") 5466 .set_path(env.get_shimmed_layer_manifest_path(0).str()) 5467 .set_treat_as_implicit_manifest(true))); 5468 env.update_loader_settings(env.loader_settings); 5469 5470 InstWrapper inst{env.vulkan_functions}; 5471 inst.CheckCreate(); 5472 5473 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1); 5474 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name)); 5475 } 5476 { 5477 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off"); 5478 env.update_loader_settings(env.loader_settings); 5479 5480 InstWrapper inst{env.vulkan_functions}; 5481 inst.CheckCreate(); 5482 5483 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5484 } 5485 { 5486 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto"); 5487 env.update_loader_settings(env.loader_settings); 5488 5489 InstWrapper inst{env.vulkan_functions}; 5490 inst.CheckCreate(); 5491 5492 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0)); 5493 } 5494} 5495