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
CheckLogForLayerString(FrameworkEnvironment& env, const char* implicit_layer_name, bool check_for_enable)30 void 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
44 const char* lunarg_meta_layer_name = "VK_LAYER_LUNARG_override";
45
TEST(ImplicitLayers, WithEnableAndDisableEnvVar)46 TEST(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
TEST(ImplicitLayers, OnlyDisableEnvVar)92 TEST(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
TEST(ImplicitLayers, PreInstanceEnumInstLayerProps)127 TEST(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
TEST(ImplicitLayers, PreInstanceEnumInstExtProps)161 TEST(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
TEST(ImplicitLayers, PreInstanceVersion)195 TEST(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).
TEST(ImplicitLayers, OverrideGetInstanceProcAddr)236 TEST(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
TEST(ImplicitLayers, EnableWithFilter)267 TEST(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
TEST(ImplicitLayers, DisableWithFilter)488 TEST(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
TEST(ImplicitLayers, DisableWithFilterWhenLayersEnableEnvVarIsActive)677 TEST(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.
TEST(ImplicitLayers, EnableAndDisableWithFilter)782 TEST(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.
TEST(ImplicitLayers, DuplicateLayers)961 TEST(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.
TEST(MetaLayers, InvalidComponentLayer)1013 TEST(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
TEST(MetaLayers, ExplicitMetaLayer)1053 TEST(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
TEST(MetaLayers, MetaLayerNameInComponentLayers)1094 TEST(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
TEST(MetaLayers, MetaLayerWhichAddsMetaLayer)1132 TEST(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
TEST(MetaLayers, InstanceExtensionInComponentLayer)1169 TEST(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
TEST(MetaLayers, DeviceExtensionInComponentLayer)1190 TEST(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
TEST(OverrideMetaLayer, InvalidDisableEnvironment)1233 TEST(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
TEST(OverrideMetaLayer, OlderVersionThanInstance)1260 TEST(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
TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion)1303 TEST(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
TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer)1347 TEST(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
TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer)1399 TEST(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
TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist)1449 TEST(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
TEST(OverrideMetaLayer, BasicOverridePaths)1501 TEST(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
TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers)1532 TEST(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
TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH)1572 TEST(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
TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths)1622 TEST(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
TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld)1662 TEST(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
TEST(OverrideMetaLayer, AppKeysDoesContainCurrentApplication)1694 TEST(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
TEST(OverrideMetaLayer, AppKeysDoesNotContainCurrentApplication)1727 TEST(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
TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromSecureLocation)1756 TEST(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
TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromUnsecureLocation)1811 TEST(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
TEST(ExplicitLayers, OverridePreInstanceFunctions)1864 TEST(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
TEST(ExplicitLayers, LayerSettingsPreInstanceFunctions)1917 TEST(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
TEST(ExplicitLayers, ContainsPreInstanceFunctions)1969 TEST(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.
TEST(LayerCreateInstance, GetPhysicalDeviceProperties2)2016 TEST(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
TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR)2055 TEST(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
TEST(ExplicitLayers, MultipleLayersInSingleManifest)2088 TEST(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
TEST(ExplicitLayers, WrapObjects)2113 TEST(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
TEST(ExplicitLayers, VkLayerPathEnvVar)2172 TEST(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
TEST(ExplicitLayers, DuplicateLayersInVK_LAYER_PATH)2242 TEST(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
TEST(ExplicitLayers, DuplicateLayersInVK_ADD_LAYER_PATH)2317 TEST(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
TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayers)2392 TEST(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
TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayersFromSystemLocations)2458 TEST(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
TEST(ExplicitLayers, CorrectOrderOfApplicationEnabledLayers)2518 TEST(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
TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension)2581 TEST(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
TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension)2621 TEST(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
TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension)2665 TEST(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
TEST(LayerExtensions, ImplicitBothInstanceExtensions)2706 TEST(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
TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension)2751 TEST(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
TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension)2781 TEST(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
TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension)2824 TEST(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
TEST(LayerExtensions, ExplicitBothInstanceExtensions)2867 TEST(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
TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension)2927 TEST(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
TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension)2985 TEST(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
TEST(LayerExtensions, ImplicitPresentImageDeviceExtension)3022 TEST(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
TEST(LayerExtensions, ImplicitBothDeviceExtensions)3059 TEST(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
TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension)3097 TEST(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
TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension)3127 TEST(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
TEST(LayerExtensions, ExplicitPresentImageDeviceExtension)3161 TEST(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
TEST(LayerExtensions, ExplicitBothDeviceExtensions)3196 TEST(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
TEST(TestLayers, ExplicitlyEnableImplicitLayer)3242 TEST(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
TEST(TestLayers, NewerInstanceVersionThanImplicitLayer)3273 TEST(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
TEST(TestLayers, ImplicitLayerPre10APIVersion)3314 TEST(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
TEST(TestLayers, InstEnvironEnableExplicitLayer)3376 TEST(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
TEST(TestLayers, EnvironLayerEnableExplicitLayer)3438 TEST(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
TEST(TestLayers, EnvironLayerDisableExplicitLayer)3624 TEST(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)
TEST(TestLayers, EnvironLayerEnableDisableExplicitLayer)3861 TEST(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)
TEST(TestLayers, EnvironVkInstanceLayersAndDisableFilters)4055 TEST(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
TEST(TestLayers, NonExistantLayerInVK_INSTANCE_LAYERS)4134 TEST(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
TEST(TestLayers, DuplicatesInEnvironVK_INSTANCE_LAYERS)4181 TEST(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
TEST(TestLayers, AppEnabledExplicitLayerFails)4203 TEST(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
TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilter)4232 TEST(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
TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer)4282 TEST(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
TEST(TestLayers, OverrideBlacklistedLayerWithEnableFilter)4332 TEST(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
TEST(TestLayers, DoNotUseDeviceLayer)4382 TEST(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.
TEST(TestLayers, InstanceAndDeviceLayer)4442 TEST(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
TEST(TestLayers, DeviceLayerNotPresent)4479 TEST(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
TEST(LayerPhysDeviceMod, AddPhysicalDevices)4495 TEST(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
TEST(LayerPhysDeviceMod, RemovePhysicalDevices)4572 TEST(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
TEST(LayerPhysDeviceMod, ReorderPhysicalDevices)4622 TEST(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
TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices)4672 TEST(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
GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDeviceGroupProperties b)4736 bool 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
TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups)4748 TEST(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
TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups)4834 TEST(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
TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups)4887 TEST(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
TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups)4939 TEST(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
TEST(TestLayers, AllowFilterWithExplicitLayer)5012 TEST(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
TEST(TestLayers, AllowFilterWithImplicitLayer)5089 TEST(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
TEST(TestLayers, AllowFilterWithConditionallyImlicitLayer)5242 TEST(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
TEST(TestLayers, AllowFilterWithConditionallyImlicitLayerWithOverrideLayer)5397 TEST(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