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();
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();
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 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
966 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
967 .set_name(same_layer_name_1)
968 .set_description("actually_layer_1")
969 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
970 .set_disable_environment("if_you_can")),
971 "regular_layer_1.json"));
972 auto& layer1 = env.get_test_layer(0);
973 layer1.set_description("actually_layer_1");
974 layer1.set_make_spurious_log_in_create_instance("actually_layer_1");
975
976 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
977 .set_name(same_layer_name_1)
978 .set_description("actually_layer_2")
979 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
980 .set_disable_environment("if_you_can")),
981 "regular_layer_1.json")
982 // use override folder as just a folder and manually add it to the implicit layer search paths
983 .set_discovery_type(ManifestDiscoveryType::override_folder));
984 auto& layer2 = env.get_test_layer(1);
985 layer2.set_description("actually_layer_2");
986 layer2.set_make_spurious_log_in_create_instance("actually_layer_2");
987 #if defined(WIN32)
988 env.platform_shim->add_manifest(ManifestCategory::implicit_layer, env.get_folder(ManifestLocation::override_layer).location());
989 #elif COMMON_UNIX_PLATFORMS
990 env.platform_shim->redirect_path(std::filesystem::path(USER_LOCAL_SHARE_DIR "/vulkan/implicit_layer.d"),
991 env.get_folder(ManifestLocation::override_layer).location());
992 #endif
993
994 auto layer_props = env.GetLayerProperties(2);
995 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName));
996 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName));
997 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
998 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
999
1000 InstWrapper inst{env.vulkan_functions};
1001 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1002 inst.CheckCreate();
1003
1004 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
1005 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
1006 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
1007 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
1008 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
1009 }
1010
TEST(ImplicitLayers,VkImplicitLayerPathEnvVar)1011 TEST(ImplicitLayers, VkImplicitLayerPathEnvVar) {
1012 FrameworkEnvironment env;
1013 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1014
1015 // verify layer loads successfully when setting VK_IMPLICIT_LAYER_PATH to a full filepath
1016 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
1017 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1018 .set_name(regular_layer_name_1)
1019 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1020 .set_disable_environment("Yikes")),
1021 "regular_layer_1.json")
1022 .set_discovery_type(ManifestDiscoveryType::env_var)
1023 .set_is_dir(false));
1024
1025 InstWrapper inst(env.vulkan_functions);
1026 inst.CheckCreate();
1027 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
1028 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name_1));
1029 }
1030
TEST(ImplicitLayers,VkImplicitLayerPathEnvVarContainsMultipleFilePaths)1031 TEST(ImplicitLayers, VkImplicitLayerPathEnvVarContainsMultipleFilePaths) {
1032 FrameworkEnvironment env;
1033 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1034
1035 // verify layers load successfully when setting VK_IMPLICIT_LAYER_PATH to multiple full filepaths
1036 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
1037 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1038 .set_name(regular_layer_name_1)
1039 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1040 .set_disable_environment("Yikes")),
1041 "regular_layer_1.json")
1042 .set_discovery_type(ManifestDiscoveryType::env_var)
1043 .set_is_dir(false));
1044
1045 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
1046 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1047 .set_name(regular_layer_name_2)
1048 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1049 .set_disable_environment("Yikes")),
1050 "regular_layer_2.json")
1051 .set_discovery_type(ManifestDiscoveryType::env_var)
1052 .set_is_dir(false));
1053
1054 InstWrapper inst(env.vulkan_functions);
1055 inst.CheckCreate();
1056 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1057 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props));
1058 }
1059
TEST(ImplicitLayers,VkImplicitLayerPathEnvVarIsDirectory)1060 TEST(ImplicitLayers, VkImplicitLayerPathEnvVarIsDirectory) {
1061 FrameworkEnvironment env;
1062 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1063
1064 // verify layers load successfully when setting VK_IMPLICIT_LAYER_PATH to a directory
1065 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
1066 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1067 .set_name(regular_layer_name_1)
1068 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1069 .set_disable_environment("Yikes")),
1070 "regular_layer_1.json")
1071 .set_discovery_type(ManifestDiscoveryType::env_var));
1072
1073 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
1074 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1075 .set_name(regular_layer_name_2)
1076 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1077 .set_disable_environment("Yikes")),
1078 "regular_layer_2.json")
1079 .set_discovery_type(ManifestDiscoveryType::env_var));
1080
1081 InstWrapper inst(env.vulkan_functions);
1082 inst.CheckCreate();
1083 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1084 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props));
1085 }
1086
1087 // Test to make sure order layers are found in VK_IMPLICIT_LAYER_PATH is what decides which layer is loaded
TEST(ImplicitLayers,DuplicateLayersInVkImplicitLayerPath)1088 TEST(ImplicitLayers, DuplicateLayersInVkImplicitLayerPath) {
1089 FrameworkEnvironment env;
1090 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1091
1092 const char* layer_name = "VK_LAYER_RegularLayer1";
1093 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1094 .set_name(layer_name)
1095 .set_description("actually_layer_1")
1096 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1097 .set_disable_environment("Boo!")),
1098 "layer.json")
1099 .set_discovery_type(ManifestDiscoveryType::env_var)
1100 .set_is_dir(true));
1101 auto& layer1 = env.get_test_layer(0);
1102 layer1.set_description("actually_layer_1");
1103
1104 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1105 .set_name(layer_name)
1106 .set_description("actually_layer_2")
1107 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1108 .set_disable_environment("Ah!")),
1109 "layer.json")
1110 // putting it in a separate folder then manually adding the folder to VK_IMPLICIT_LAYER_PATH
1111 .set_discovery_type(ManifestDiscoveryType::override_folder)
1112 .set_is_dir(true));
1113 auto& layer2 = env.get_test_layer(1);
1114 layer2.set_description("actually_layer_2");
1115 env.env_var_vk_implicit_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location().string());
1116
1117 auto layer_props = env.GetLayerProperties(2);
1118 ASSERT_TRUE(string_eq(layer_name, layer_props[0].layerName));
1119 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
1120 ASSERT_TRUE(string_eq(layer_name, layer_props[1].layerName));
1121 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
1122
1123 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
1124 inst_layers_env_var.add_to_list(layer_name);
1125
1126 InstWrapper inst{env.vulkan_functions};
1127 inst.CheckCreate();
1128
1129 // Expect the first layer added to be found
1130 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
1131 ASSERT_TRUE(string_eq(layer_name, enabled_layer_props[0].layerName));
1132 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description));
1133 }
1134
TEST(ImplicitLayers,DuplicateLayersInVK_ADD_IMPLICIT_LAYER_PATH)1135 TEST(ImplicitLayers, DuplicateLayersInVK_ADD_IMPLICIT_LAYER_PATH) {
1136 FrameworkEnvironment env;
1137 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1138
1139 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
1140 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1141 .set_name(same_layer_name_1)
1142 .set_description("actually_layer_1")
1143 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1144 .set_disable_environment("Red")),
1145 "regular_layer_1.json")
1146 // use override folder as just a folder and manually set the VK_ADD_IMPLICIT_LAYER_PATH env-var to it
1147 .set_discovery_type(ManifestDiscoveryType::override_folder)
1148 .set_is_dir(true));
1149 auto& layer1 = env.get_test_layer(0);
1150 layer1.set_description("actually_layer_1");
1151 layer1.set_make_spurious_log_in_create_instance("actually_layer_1");
1152 env.add_env_var_vk_implicit_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location());
1153
1154 env.add_implicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1155 .set_name(same_layer_name_1)
1156 .set_description("actually_layer_2")
1157 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1158 .set_disable_environment("Blue")),
1159 "regular_layer_1.json")
1160 .set_discovery_type(ManifestDiscoveryType::add_env_var)
1161 .set_is_dir(true));
1162 auto& layer2 = env.get_test_layer(1);
1163 layer2.set_description("actually_layer_2");
1164 layer2.set_make_spurious_log_in_create_instance("actually_layer_2");
1165
1166 auto layer_props = env.GetLayerProperties(2);
1167 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName));
1168 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName));
1169 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
1170 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
1171
1172 InstWrapper inst{env.vulkan_functions};
1173 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1174 inst.CheckCreate();
1175 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
1176 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
1177 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
1178 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
1179 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
1180 }
1181
1182 // Meta layer which contains component layers that do not exist.
TEST(MetaLayers,InvalidComponentLayer)1183 TEST(MetaLayers, InvalidComponentLayer) {
1184 FrameworkEnvironment env;
1185 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
1186 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1187 const char* invalid_layer_name_1 = "VK_LAYER_InvalidLayer1";
1188 const char* invalid_layer_name_2 = "VK_LAYER_InvalidLayer2";
1189 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1190 ManifestLayer::LayerDescription{}
1191 .set_name(meta_layer_name)
1192 .add_component_layers({invalid_layer_name_1, invalid_layer_name_2})
1193 .set_disable_environment("NotGonnaWork")
1194 .add_instance_extension({"NeverGonnaGiveYouUp"})
1195 .add_device_extension({"NeverGonnaLetYouDown"})),
1196 "meta_test_layer.json");
1197
1198 const char* regular_layer_name = "TestLayer";
1199 env.add_explicit_layer(
1200 ManifestLayer{}.add_layer(
1201 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1202 "regular_test_layer.json");
1203
1204 // should find 1, the 'regular' layer
1205 auto layer_props = env.GetLayerProperties(1);
1206 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name));
1207
1208 auto extensions = env.GetInstanceExtensions(4);
1209 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
1210 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
1211 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
1212 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
1213
1214 InstWrapper inst{env.vulkan_functions};
1215 inst.create_info.add_layer(meta_layer_name);
1216 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1217 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
1218 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
1219 " can't find component layer " + invalid_layer_name_1 + " at index 0. Skipping this layer."));
1220 }
1221
1222 // Meta layer that is an explicit layer
TEST(MetaLayers,ExplicitMetaLayer)1223 TEST(MetaLayers, ExplicitMetaLayer) {
1224 FrameworkEnvironment env;
1225 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1226 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1227 const char* regular_layer_name = "VK_LAYER_TestLayer";
1228 env.add_explicit_layer(
1229 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1230 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
1231 "meta_test_layer.json");
1232
1233 env.add_explicit_layer(
1234 ManifestLayer{}.add_layer(
1235 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1236 "regular_test_layer.json");
1237
1238 { // global functions
1239 // should find 1, the 'regular' layer
1240 auto layer_props = env.GetLayerProperties(2);
1241 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props));
1242
1243 auto extensions = env.GetInstanceExtensions(4);
1244 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
1245 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
1246 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
1247 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
1248 }
1249 { // don't enable the layer, shouldn't find any layers when calling vkEnumerateDeviceLayerProperties
1250 InstWrapper inst{env.vulkan_functions};
1251 inst.CheckCreate();
1252 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
1253 }
1254 {
1255 InstWrapper inst{env.vulkan_functions};
1256 inst.create_info.add_layer(meta_layer_name);
1257 inst.CheckCreate();
1258 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1259 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props));
1260 }
1261 }
1262
1263 // Meta layer which adds itself in its list of component layers
TEST(MetaLayers,MetaLayerNameInComponentLayers)1264 TEST(MetaLayers, MetaLayerNameInComponentLayers) {
1265 FrameworkEnvironment env;
1266 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
1267 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1268 const char* regular_layer_name = "VK_LAYER_TestLayer";
1269 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1270 ManifestLayer::LayerDescription{}
1271 .set_name(meta_layer_name)
1272 .add_component_layers({meta_layer_name, regular_layer_name})
1273 .set_disable_environment("NotGonnaWork")
1274 .add_instance_extension({"NeverGonnaGiveYouUp"})
1275 .add_device_extension({"NeverGonnaLetYouDown"})),
1276 "meta_test_layer.json");
1277
1278 env.add_explicit_layer(
1279 ManifestLayer{}.add_layer(
1280 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1281 "regular_test_layer.json");
1282
1283 // should find 1, the 'regular' layer
1284 auto layer_props = env.GetLayerProperties(1);
1285 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name));
1286
1287 auto extensions = env.GetInstanceExtensions(4);
1288 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
1289 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
1290 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
1291 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
1292
1293 InstWrapper inst{env.vulkan_functions};
1294 inst.create_info.add_layer(meta_layer_name);
1295 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1296 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
1297 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
1298 " lists itself in its component layer " + "list at index 0. Skipping this layer."));
1299 }
1300
1301 // Meta layer which adds another meta layer as a component layer
TEST(MetaLayers,MetaLayerWhichAddsMetaLayer)1302 TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) {
1303 FrameworkEnvironment env;
1304 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
1305 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1306 const char* meta_meta_layer_name = "VK_LAYER_MetaMetaTestLayer";
1307 const char* regular_layer_name = "VK_LAYER_TestLayer";
1308 env.add_explicit_layer(
1309 ManifestLayer{}.add_layer(
1310 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1311 "regular_test_layer.json");
1312 env.add_explicit_layer(
1313 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1314 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
1315 "meta_test_layer.json");
1316 env.add_explicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1317 ManifestLayer::LayerDescription{}
1318 .set_name(meta_meta_layer_name)
1319 .add_component_layers({meta_layer_name, regular_layer_name})),
1320 "meta_meta_test_layer.json");
1321
1322 auto layer_props = env.GetLayerProperties(3);
1323 EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name, meta_meta_layer_name}, layer_props));
1324
1325 auto extensions = env.GetInstanceExtensions(4);
1326 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
1327 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
1328 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
1329 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
1330
1331 InstWrapper inst{env.vulkan_functions};
1332 inst.create_info.add_layer(meta_layer_name);
1333 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1334 inst.CheckCreate();
1335 ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Adding meta-layer ") + meta_meta_layer_name +
1336 " which also contains meta-layer " + meta_layer_name));
1337 }
1338
TEST(MetaLayers,InstanceExtensionInComponentLayer)1339 TEST(MetaLayers, InstanceExtensionInComponentLayer) {
1340 FrameworkEnvironment env;
1341 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1342
1343 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1344 const char* regular_layer_name = "VK_LAYER_TestLayer";
1345 const char* instance_ext_name = "VK_EXT_headless_surface";
1346 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1347 .set_name(regular_layer_name)
1348 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1349 .add_instance_extension({instance_ext_name})),
1350 "regular_test_layer.json");
1351 env.add_explicit_layer(
1352 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1353 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
1354 "meta_test_layer.json");
1355
1356 auto extensions = env.GetInstanceExtensions(1, meta_layer_name);
1357 EXPECT_TRUE(string_eq(extensions[0].extensionName, instance_ext_name));
1358 }
1359
TEST(MetaLayers,DeviceExtensionInComponentLayer)1360 TEST(MetaLayers, DeviceExtensionInComponentLayer) {
1361 FrameworkEnvironment env;
1362 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1363
1364 const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
1365 const char* regular_layer_name = "VK_LAYER_TestLayer";
1366 const char* device_ext_name = "VK_EXT_fake_dev_ext";
1367 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1368 .set_name(regular_layer_name)
1369 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1370 .add_device_extension({device_ext_name})),
1371 "regular_test_layer.json");
1372 env.add_explicit_layer(
1373 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
1374 ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
1375 "meta_test_layer.json");
1376
1377 ASSERT_NO_FATAL_FAILURE(env.GetInstanceExtensions(0, meta_layer_name));
1378
1379 { // layer is not enabled
1380 InstWrapper inst{env.vulkan_functions};
1381 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1382 inst.CheckCreate();
1383 ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
1384 " adding device extension " + device_ext_name));
1385
1386 auto extensions = inst.EnumerateLayerDeviceExtensions(inst.GetPhysDev(), meta_layer_name, 1);
1387 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, device_ext_name));
1388 }
1389 { // layer is enabled
1390 InstWrapper inst{env.vulkan_functions};
1391 inst.create_info.add_layer(meta_layer_name);
1392 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1393 inst.CheckCreate();
1394 ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
1395 " adding device extension " + device_ext_name));
1396
1397 auto extensions = inst.EnumerateLayerDeviceExtensions(inst.GetPhysDev(), meta_layer_name, 1);
1398 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, device_ext_name));
1399 }
1400 }
1401
1402 // Override meta layer missing disable environment variable still enables the layer
TEST(OverrideMetaLayer,InvalidDisableEnvironment)1403 TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
1404 FrameworkEnvironment env;
1405 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1406
1407 const char* regular_layer_name = "VK_LAYER_TestLayer";
1408 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1409 .set_name(regular_layer_name)
1410 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1411 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1412 .add_device_extension({"NeverGonnaLetYouDown"})),
1413 "regular_test_layer.json");
1414
1415 env.add_implicit_layer(
1416 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{}
1417 .set_name(lunarg_meta_layer_name)
1418 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1419 .add_component_layers({regular_layer_name})),
1420 "meta_test_layer.json");
1421
1422 auto layer_props = env.GetLayerProperties(1);
1423 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1424
1425 InstWrapper inst{env.vulkan_functions};
1426 inst.CheckCreate();
1427 }
1428
1429 // Override meta layer whose version is less than the api version of the instance
TEST(OverrideMetaLayer,OlderVersionThanInstance)1430 TEST(OverrideMetaLayer, OlderVersionThanInstance) {
1431 FrameworkEnvironment env;
1432 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1433
1434 const char* regular_layer_name = "VK_LAYER_TestLayer";
1435 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1436 .set_name(regular_layer_name)
1437 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1438 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1439 .add_device_extension({"NeverGonnaLetYouDown"})),
1440 "regular_test_layer.json");
1441
1442 env.add_implicit_layer(
1443 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{}
1444 .set_name(lunarg_meta_layer_name)
1445 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1446 .set_disable_environment("DisableMeIfYouCan")
1447 .add_component_layers({regular_layer_name})),
1448 "meta_test_layer.json");
1449 { // global functions
1450 auto layer_props = env.GetLayerProperties(2);
1451 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1452 }
1453 { // 1.1 instance
1454 InstWrapper inst{env.vulkan_functions};
1455 inst.create_info.api_version = VK_API_VERSION_1_1;
1456 inst.CheckCreate();
1457 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1458 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1459 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
1460 }
1461 { // 1.3 instance
1462
1463 InstWrapper inst{env.vulkan_functions};
1464 inst.create_info.api_version = VK_API_VERSION_1_3;
1465 inst.CheckCreate();
1466 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1467
1468 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1469 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
1470 }
1471 }
1472
TEST(OverrideMetaLayer,OlderMetaLayerWithNewerInstanceVersion)1473 TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
1474 FrameworkEnvironment env;
1475 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1476
1477 const char* regular_layer_name = "VK_LAYER_TestLayer";
1478 env.add_explicit_layer(
1479 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1480 .set_name(regular_layer_name)
1481 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1482 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
1483 "regular_test_layer.json");
1484
1485 env.add_implicit_layer(
1486 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1487 .set_name(lunarg_meta_layer_name)
1488 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1489 .add_component_layers({regular_layer_name})
1490 .set_disable_environment("DisableMeIfYouCan")),
1491 "meta_test_layer.json");
1492 { // global functions
1493 auto layer_props = env.GetLayerProperties(2);
1494 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1495 }
1496 {
1497 // 1.1 instance
1498 InstWrapper inst{env.vulkan_functions};
1499 inst.create_info.set_api_version(1, 1, 0);
1500 inst.CheckCreate();
1501 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1502 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1503 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
1504 }
1505
1506 {
1507 // 1.3 instance
1508 InstWrapper inst{env.vulkan_functions};
1509 inst.create_info.set_api_version(1, 3, 0);
1510 inst.CheckCreate();
1511 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1512 ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1513 ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
1514 }
1515 }
1516
TEST(OverrideMetaLayer,NewerComponentLayerInMetaLayer)1517 TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
1518 FrameworkEnvironment env;
1519 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1520
1521 const char* regular_layer_name = "VK_LAYER_TestLayer";
1522 env.add_explicit_layer(
1523 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1524 .set_name(regular_layer_name)
1525 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1526 .set_api_version(VK_API_VERSION_1_2)),
1527 "regular_test_layer.json");
1528
1529 env.add_implicit_layer(
1530 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1531 .set_name(lunarg_meta_layer_name)
1532 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1533 .add_component_layers({regular_layer_name})
1534 .set_disable_environment("DisableMeIfYouCan")),
1535 "meta_test_layer.json");
1536
1537 { // global functions
1538 auto layer_props = env.GetLayerProperties(2);
1539 // Expect the explicit layer to still be found
1540 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1541 }
1542 {
1543 // 1.1 instance
1544 InstWrapper inst{env.vulkan_functions};
1545 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1546 inst.create_info.set_api_version(1, 1, 0);
1547 inst.CheckCreate();
1548 // Newer component is allowed now
1549 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1550 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1551 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1552 }
1553 env.debug_log.clear();
1554
1555 {
1556 // 1.3 instance
1557 InstWrapper inst{env.vulkan_functions};
1558 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1559 inst.create_info.set_api_version(1, 3, 0);
1560 inst.CheckCreate();
1561 // Newer component is allowed now
1562 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1563 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1564
1565 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1566 }
1567 }
1568
TEST(OverrideMetaLayer,OlderComponentLayerInMetaLayer)1569 TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
1570 FrameworkEnvironment env;
1571 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1572
1573 const char* regular_layer_name = "VK_LAYER_TestLayer";
1574 env.add_explicit_layer(
1575 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1576 .set_name(regular_layer_name)
1577 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1578 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
1579 "regular_test_layer.json");
1580
1581 env.add_implicit_layer(
1582 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1583 .set_name(lunarg_meta_layer_name)
1584 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1585 .add_component_layers({regular_layer_name})
1586 .set_disable_environment("DisableMeIfYouCan")),
1587 "meta_test_layer.json");
1588 { // global functions
1589 auto layer_props = env.GetLayerProperties(1);
1590 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1591 }
1592 {
1593 // 1.1 instance
1594 InstWrapper inst{env.vulkan_functions};
1595 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1596 inst.create_info.set_api_version(1, 1, 0);
1597 inst.CheckCreate();
1598 EXPECT_TRUE(
1599 env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 has API "
1600 "version 1.0 that is lower. Skipping this layer."));
1601 env.debug_log.clear();
1602 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
1603 }
1604
1605 {
1606 // 1.2 instance
1607 InstWrapper inst{env.vulkan_functions};
1608 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1609 inst.create_info.set_api_version(1, 2, 0);
1610 inst.CheckCreate();
1611 ASSERT_TRUE(
1612 env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 has API "
1613 "version 1.0 that is lower. Skipping this layer."));
1614 env.debug_log.clear();
1615 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
1616 }
1617 }
1618
TEST(OverrideMetaLayer,ApplicationEnabledLayerInBlacklist)1619 TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
1620 FrameworkEnvironment env;
1621 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1622
1623 const char* automatic_regular_layer_name = "VK_LAYER_TestLayer_1";
1624 const char* manual_regular_layer_name = "VK_LAYER_TestLayer_2";
1625 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1626 .set_name(automatic_regular_layer_name)
1627 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1628 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
1629 "regular_test_layer_1.json");
1630 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1631 .set_name(manual_regular_layer_name)
1632 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1633 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
1634 "regular_test_layer_2.json");
1635 env.add_implicit_layer(
1636 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1637 .set_name(lunarg_meta_layer_name)
1638 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1639 .add_component_layer(automatic_regular_layer_name)
1640 .add_blacklisted_layer(manual_regular_layer_name)
1641 .set_disable_environment("DisableMeIfYouCan")),
1642 "meta_test_layer.json");
1643 { // Check that enumerating the layers returns only the non-blacklisted layers + override layer
1644 auto layer_props = env.GetLayerProperties(2);
1645 ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props));
1646 }
1647 {
1648 // enable the layer in the blacklist
1649 InstWrapper inst{env.vulkan_functions};
1650 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1651 inst.create_info.add_layer(manual_regular_layer_name);
1652 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
1653 ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
1654 manual_regular_layer_name +
1655 " is in the blacklist inside of it. Removing that layer from current layer list."));
1656 env.debug_log.clear();
1657 }
1658 { // dont enable the layer in the blacklist
1659 InstWrapper inst{env.vulkan_functions};
1660 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1661 inst.CheckCreate();
1662 ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
1663 manual_regular_layer_name +
1664 " is in the blacklist inside of it. Removing that layer from current layer list."));
1665 env.debug_log.clear();
1666 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1667 ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props));
1668 }
1669 }
1670
TEST(OverrideMetaLayer,BasicOverridePaths)1671 TEST(OverrideMetaLayer, BasicOverridePaths) {
1672 FrameworkEnvironment env;
1673 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1674
1675 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1676
1677 const char* regular_layer_name = "VK_LAYER_TestLayer_1";
1678 override_layer_folder.write_manifest("regular_test_layer.json",
1679 ManifestLayer{}
1680 .add_layer(ManifestLayer::LayerDescription{}
1681 .set_name(regular_layer_name)
1682 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1683 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1684 .get_manifest_str());
1685 env.add_implicit_layer(
1686 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1687 .set_name(lunarg_meta_layer_name)
1688 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1689 .add_component_layer(regular_layer_name)
1690 .set_disable_environment("DisableMeIfYouCan")
1691 .add_override_path(override_layer_folder.location())),
1692 "meta_test_layer.json");
1693
1694 InstWrapper inst{env.vulkan_functions};
1695 inst.create_info.set_api_version(1, 1, 0);
1696 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1697 inst.CheckCreate();
1698 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1699 env.layers.clear();
1700 }
1701
TEST(OverrideMetaLayer,BasicOverridePathsIgnoreOtherLayers)1702 TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
1703 FrameworkEnvironment env;
1704 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1705
1706 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1707
1708 const char* regular_layer_name = "VK_LAYER_TestLayer";
1709 env.add_explicit_layer(
1710 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1711 .set_name(regular_layer_name)
1712 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1713 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
1714 "regular_test_layer.json");
1715
1716 const char* special_layer_name = "VK_LAYER_TestLayer_1";
1717 override_layer_folder.write_manifest("regular_test_layer.json",
1718 ManifestLayer{}
1719 .add_layer(ManifestLayer::LayerDescription{}
1720 .set_name(special_layer_name)
1721 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1722 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1723 .get_manifest_str());
1724 env.add_implicit_layer(
1725 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1726 .set_name(lunarg_meta_layer_name)
1727 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1728 .add_component_layer(special_layer_name)
1729 .set_disable_environment("DisableMeIfYouCan")
1730 .add_override_path(override_layer_folder.location())),
1731 "meta_test_layer.json");
1732
1733 InstWrapper inst{env.vulkan_functions};
1734 inst.create_info.set_api_version(1, 1, 0);
1735 inst.create_info.add_layer(regular_layer_name);
1736 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1737 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
1738 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1739 env.layers.clear();
1740 }
1741
TEST(OverrideMetaLayer,OverridePathsInteractionWithVK_LAYER_PATH)1742 TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
1743 FrameworkEnvironment env;
1744 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1745
1746 // add explicit layer to VK_LAYER_PATH folder
1747 const char* env_var_layer_name = "VK_LAYER_env_var_set_path";
1748 env.add_explicit_layer(TestLayerDetails{
1749 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1750 .set_name(env_var_layer_name)
1751 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1752 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
1753 "regular_test_layer.json"}
1754 .set_discovery_type(ManifestDiscoveryType::env_var));
1755
1756 // add layer to regular explicit layer folder
1757 const char* regular_layer_name = "VK_LAYER_regular_layer_path";
1758 env.add_explicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
1759 .set_name(regular_layer_name)
1760 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1761 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
1762 "regular_test_layer.json"}
1763 .set_discovery_type(ManifestDiscoveryType::override_folder));
1764
1765 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
1766 ManifestLayer::LayerDescription{}
1767 .set_name(lunarg_meta_layer_name)
1768 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1769 .add_component_layer(regular_layer_name)
1770 .set_disable_environment("DisableMeIfYouCan")
1771 .add_override_path(env.get_folder(ManifestLocation::override_layer).location())),
1772 "meta_test_layer.json");
1773
1774 auto meta_layer_path = env.get_folder(ManifestLocation::override_layer).location();
1775
1776 InstWrapper inst{env.vulkan_functions};
1777 inst.create_info.set_api_version(1, 1, 0);
1778 inst.create_info.add_layer(env_var_layer_name);
1779 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1780 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
1781 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + env_var_layer_name));
1782 ASSERT_TRUE(env.debug_log.find(
1783 std::string("Ignoring VK_LAYER_PATH. The Override layer is active and has override paths set, which takes priority. "
1784 "VK_LAYER_PATH is set to ") +
1785 env.env_var_vk_layer_paths.value()));
1786 ASSERT_TRUE(env.debug_log.find("Override layer has override paths set to " + meta_layer_path.string()));
1787
1788 env.layers.clear();
1789 }
1790
1791 // Make sure that implicit layers not in the override paths aren't found by mistake
TEST(OverrideMetaLayer,OverridePathsEnableImplicitLayerInDefaultPaths)1792 TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
1793 FrameworkEnvironment env;
1794 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1795 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1796
1797 const char* implicit_layer_name = "VK_LAYER_ImplicitLayer";
1798 env.add_implicit_layer(
1799 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1800 .set_name(implicit_layer_name)
1801 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1802 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
1803 "implicit_test_layer.json");
1804
1805 const char* regular_layer_name = "VK_LAYER_TestLayer_1";
1806 override_layer_folder.write_manifest("regular_test_layer.json",
1807 ManifestLayer{}
1808 .add_layer(ManifestLayer::LayerDescription{}
1809 .set_name(regular_layer_name)
1810 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1811 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1812 .get_manifest_str());
1813 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
1814 ManifestLayer::LayerDescription{}
1815 .set_name(lunarg_meta_layer_name)
1816 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1817 .add_component_layers({regular_layer_name, implicit_layer_name})
1818 .set_disable_environment("DisableMeIfYouCan")
1819 .add_override_path(override_layer_folder.location())),
1820 "meta_test_layer.json");
1821
1822 InstWrapper inst{env.vulkan_functions};
1823 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1824 inst.create_info.set_api_version(1, 1, 0);
1825 inst.CheckCreate();
1826 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + implicit_layer_name));
1827 ASSERT_TRUE(
1828 env.debug_log.find("Removing meta-layer VK_LAYER_LUNARG_override from instance layer list since it appears invalid."));
1829 env.layers.clear();
1830 }
1831
TEST(OverrideMetaLayer,ManifestFileFormatVersionTooOld)1832 TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
1833 FrameworkEnvironment env;
1834 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1835 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1836
1837 const char* regular_layer_name = "VK_LAYER_TestLayer_1";
1838 override_layer_folder.write_manifest("regular_test_layer.json",
1839 ManifestLayer{}
1840 .add_layer(ManifestLayer::LayerDescription{}
1841 .set_name(regular_layer_name)
1842 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1843 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1844 .get_manifest_str());
1845 env.add_implicit_layer(
1846 ManifestLayer{}.set_file_format_version({1, 0, 0}).add_layer(ManifestLayer::LayerDescription{}
1847 .set_name(lunarg_meta_layer_name)
1848 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1849 .add_component_layer(regular_layer_name)
1850 .set_disable_environment("DisableMeIfYouCan")
1851 .add_override_path(override_layer_folder.location())),
1852 "meta_test_layer.json");
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_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1859 ASSERT_TRUE(env.debug_log.find(std::string("Layer \"") + lunarg_meta_layer_name +
1860 "\" contains meta-layer-specific override paths, but using older JSON file version."));
1861 env.layers.clear();
1862 }
1863
1864 // app_key contains test executable name, should activate the override layer
TEST(OverrideMetaLayer,AppKeysDoesContainCurrentApplication)1865 TEST(OverrideMetaLayer, AppKeysDoesContainCurrentApplication) {
1866 FrameworkEnvironment env;
1867 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1868
1869 const char* regular_layer_name = "VK_LAYER_TestLayer";
1870 env.add_explicit_layer(
1871 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
1872 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1873 "regular_test_layer.json");
1874
1875 std::string cur_path = test_platform_executable_path();
1876
1877 env.add_implicit_layer(
1878 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1879 .set_name(lunarg_meta_layer_name)
1880 .add_component_layers({regular_layer_name})
1881 .set_disable_environment("DisableMeIfYouCan")
1882 .add_app_key(cur_path)),
1883 "meta_test_layer.json");
1884 { // global functions
1885 auto layer_props = env.GetLayerProperties(2);
1886 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1887 }
1888 {
1889 // instance
1890 InstWrapper inst{env.vulkan_functions};
1891 inst.CheckCreate();
1892 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1893 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1894 }
1895 }
1896
1897 // app_key contains random strings, should not activate the override layer
TEST(OverrideMetaLayer,AppKeysDoesNotContainCurrentApplication)1898 TEST(OverrideMetaLayer, AppKeysDoesNotContainCurrentApplication) {
1899 FrameworkEnvironment env;
1900 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1901
1902 const char* regular_layer_name = "VK_LAYER_TestLayer";
1903 env.add_explicit_layer(
1904 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
1905 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
1906 "regular_test_layer.json");
1907
1908 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
1909 ManifestLayer::LayerDescription{}
1910 .set_name(lunarg_meta_layer_name)
1911 .add_component_layers({regular_layer_name})
1912 .set_disable_environment("DisableMeIfYouCan")
1913 .add_app_keys({"/Hello", "Hi", "./../Uh-oh", "C:/Windows/Only"})),
1914 "meta_test_layer.json");
1915 { // global functions
1916 auto layer_props = env.GetLayerProperties(1);
1917 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
1918 }
1919 {
1920 // instance
1921 InstWrapper inst{env.vulkan_functions};
1922 inst.CheckCreate();
1923 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
1924 }
1925 }
1926
TEST(OverrideMetaLayer,RunningWithElevatedPrivilegesFromSecureLocation)1927 TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromSecureLocation) {
1928 FrameworkEnvironment env;
1929 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1930
1931 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1932
1933 const char* regular_layer_name = "VK_LAYER_TestLayer_1";
1934 override_layer_folder.write_manifest("regular_test_layer.json",
1935 ManifestLayer{}
1936 .add_layer(ManifestLayer::LayerDescription{}
1937 .set_name(regular_layer_name)
1938 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1939 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1940 .get_manifest_str());
1941 auto override_folder_location = override_layer_folder.location().string();
1942 env.add_implicit_layer(TestLayerDetails{
1943 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1944 .set_name(lunarg_meta_layer_name)
1945 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
1946 .add_component_layer(regular_layer_name)
1947 .set_disable_environment("DisableMeIfYouCan")
1948 .add_override_path(override_layer_folder.location())),
1949 "meta_test_layer.json"});
1950
1951 { // try with no elevated privileges
1952 auto layer_props = env.GetLayerProperties(2);
1953 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1954
1955 InstWrapper inst{env.vulkan_functions};
1956 inst.create_info.set_api_version(1, 1, 0);
1957 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1958 inst.CheckCreate();
1959 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1960 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1961 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1962 env.debug_log.clear();
1963 }
1964
1965 env.platform_shim->set_elevated_privilege(true);
1966
1967 { // try with elevated privileges
1968 auto layer_props = env.GetLayerProperties(2);
1969 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
1970
1971 InstWrapper inst{env.vulkan_functions};
1972 inst.create_info.set_api_version(1, 1, 0);
1973 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
1974 inst.CheckCreate();
1975 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
1976 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
1977 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, active_layer_props));
1978 }
1979 }
1980
1981 // Override layer should not be found and thus not loaded when running with elevated privileges
TEST(OverrideMetaLayer,RunningWithElevatedPrivilegesFromUnsecureLocation)1982 TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromUnsecureLocation) {
1983 FrameworkEnvironment env;
1984 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
1985
1986 fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
1987
1988 const char* regular_layer_name = "VK_LAYER_TestLayer_1";
1989 override_layer_folder.write_manifest("regular_test_layer.json",
1990 ManifestLayer{}
1991 .add_layer(ManifestLayer::LayerDescription{}
1992 .set_name(regular_layer_name)
1993 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
1994 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
1995 .get_manifest_str());
1996 env.add_implicit_layer(TestLayerDetails{
1997 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
1998 .set_name(lunarg_meta_layer_name)
1999 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
2000 .add_component_layer(regular_layer_name)
2001 .set_disable_environment("DisableMeIfYouCan")
2002 .add_override_path(override_layer_folder.location())),
2003 "meta_test_layer.json"}
2004 .set_discovery_type(ManifestDiscoveryType::unsecured_generic));
2005
2006 { // try with no elevated privileges
2007 auto layer_props = env.GetLayerProperties(2);
2008 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
2009
2010 InstWrapper inst{env.vulkan_functions};
2011 inst.create_info.set_api_version(1, 1, 0);
2012 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2013 inst.CheckCreate();
2014 ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
2015 env.debug_log.clear();
2016 auto active_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2017 EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, active_layer_props));
2018 }
2019
2020 env.platform_shim->set_elevated_privilege(true);
2021
2022 { // try with no elevated privileges
2023 ASSERT_NO_FATAL_FAILURE(env.GetLayerProperties(0));
2024
2025 InstWrapper inst{env.vulkan_functions};
2026 inst.create_info.set_api_version(1, 1, 0);
2027 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2028 inst.CheckCreate();
2029 ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
2030 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
2031 }
2032 }
2033
2034 // Makes sure explicit layers can't override pre-instance functions even if enabled by the override layer
TEST(ExplicitLayers,OverridePreInstanceFunctions)2035 TEST(ExplicitLayers, OverridePreInstanceFunctions) {
2036 FrameworkEnvironment env;
2037 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2038 const char* explicit_layer_name = "VK_LAYER_enabled_by_override";
2039 const char* disable_env_var = "DISABLE_ME";
2040
2041 env.add_explicit_layer(
2042 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
2043 ManifestLayer::LayerDescription{}
2044 .set_name(explicit_layer_name)
2045 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
2046 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2047 .set_vk_func("vkEnumerateInstanceLayerProperties")
2048 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))
2049 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2050 .set_vk_func("vkEnumerateInstanceExtensionProperties")
2051 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))
2052 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2053 .set_vk_func("vkEnumerateInstanceVersion")
2054 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
2055 "explicit_test_layer.json");
2056
2057 auto& layer = env.get_test_layer(0);
2058 layer.set_reported_layer_props(34);
2059 layer.set_reported_extension_props(22);
2060 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1));
2061
2062 env.add_implicit_layer(
2063 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{}
2064 .set_name(lunarg_meta_layer_name)
2065 .add_component_layers({explicit_layer_name})
2066 .set_disable_environment(disable_env_var)),
2067 "override_meta_layer.json");
2068
2069 uint32_t count = 0;
2070 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
2071 ASSERT_EQ(count, 2U);
2072 count = 0;
2073 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
2074 ASSERT_EQ(count, 4U);
2075
2076 uint32_t version = 0;
2077 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version));
2078 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE);
2079
2080 InstWrapper inst{env.vulkan_functions};
2081 inst.CheckCreate();
2082
2083 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2084 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name));
2085 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name));
2086 }
2087
TEST(ExplicitLayers,LayerSettingsPreInstanceFunctions)2088 TEST(ExplicitLayers, LayerSettingsPreInstanceFunctions) {
2089 FrameworkEnvironment env;
2090 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2091 const char* explicit_layer_name = "VK_LAYER_enabled_by_override";
2092
2093 env.add_explicit_layer(
2094 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
2095 ManifestLayer::LayerDescription{}
2096 .set_name(explicit_layer_name)
2097 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
2098 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2099 .set_vk_func("vkEnumerateInstanceLayerProperties")
2100 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))
2101 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2102 .set_vk_func("vkEnumerateInstanceExtensionProperties")
2103 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))
2104 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2105 .set_vk_func("vkEnumerateInstanceVersion")
2106 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
2107 "explicit_test_layer.json");
2108
2109 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
2110 LoaderSettingsLayerConfiguration{}
2111 .set_name(explicit_layer_name)
2112 .set_control("on")
2113 .set_path(env.get_shimmed_layer_manifest_path(0))
2114 .set_treat_as_implicit_manifest(false)));
2115 env.update_loader_settings(env.loader_settings);
2116
2117 auto& layer = env.get_test_layer(0);
2118 layer.set_reported_layer_props(34);
2119 layer.set_reported_extension_props(22);
2120 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1));
2121
2122 uint32_t count = 0;
2123 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
2124 ASSERT_EQ(count, 1U);
2125 count = 0;
2126 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
2127 ASSERT_EQ(count, 4U);
2128
2129 uint32_t version = 0;
2130 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version));
2131 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE);
2132
2133 InstWrapper inst{env.vulkan_functions};
2134 inst.CheckCreate();
2135
2136 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2137 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name));
2138 }
2139
TEST(ExplicitLayers,ContainsPreInstanceFunctions)2140 TEST(ExplicitLayers, ContainsPreInstanceFunctions) {
2141 FrameworkEnvironment env;
2142 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2143 const char* explicit_layer_name = "VK_LAYER_enabled_by_override";
2144
2145 env.add_explicit_layer(
2146 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
2147 ManifestLayer::LayerDescription{}
2148 .set_name(explicit_layer_name)
2149 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
2150 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2151 .set_vk_func("vkEnumerateInstanceLayerProperties")
2152 .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))
2153 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2154 .set_vk_func("vkEnumerateInstanceExtensionProperties")
2155 .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))
2156 .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
2157 .set_vk_func("vkEnumerateInstanceVersion")
2158 .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
2159 "explicit_test_layer.json");
2160
2161 auto& layer = env.get_test_layer(0);
2162 layer.set_reported_layer_props(34);
2163 layer.set_reported_extension_props(22);
2164 layer.set_reported_instance_version(VK_MAKE_API_VERSION(1, 0, 0, 1));
2165
2166 uint32_t count = 0;
2167 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
2168 ASSERT_EQ(count, 1U);
2169 count = 0;
2170 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
2171 ASSERT_EQ(count, 4U);
2172
2173 uint32_t version = 0;
2174 ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version));
2175 ASSERT_EQ(version, VK_HEADER_VERSION_COMPLETE);
2176
2177 InstWrapper inst{env.vulkan_functions};
2178 inst.create_info.add_layer(explicit_layer_name);
2179 inst.CheckCreate();
2180
2181 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2182 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name));
2183 }
2184
TEST(ExplicitLayers,CallsPreInstanceFunctionsInCreateInstance)2185 TEST(ExplicitLayers, CallsPreInstanceFunctionsInCreateInstance) {
2186 FrameworkEnvironment env;
2187 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2188 const char* explicit_layer_name = "VK_LAYER_enabled_by_override";
2189
2190 env.add_explicit_layer(
2191 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
2192 ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2193 "explicit_test_layer.json");
2194
2195 auto& layer = env.get_test_layer(0);
2196 layer.set_query_vkEnumerateInstanceLayerProperties(true);
2197 layer.set_query_vkEnumerateInstanceExtensionProperties(true);
2198 layer.set_query_vkEnumerateInstanceVersion(true);
2199
2200 InstWrapper inst{env.vulkan_functions};
2201 inst.create_info.add_layer(explicit_layer_name);
2202 inst.CheckCreate();
2203
2204 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2205 ASSERT_TRUE(string_eq(layers.at(0).layerName, explicit_layer_name));
2206 }
2207
2208 // This test makes sure that any layer calling GetPhysicalDeviceProperties2 inside of CreateInstance
2209 // succeeds and doesn't crash.
TEST(LayerCreateInstance,GetPhysicalDeviceProperties2)2210 TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
2211 FrameworkEnvironment env;
2212 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
2213 .add_physical_device({})
2214 .set_icd_api_version(VK_API_VERSION_1_1);
2215
2216 const char* regular_layer_name = "VK_LAYER_TestLayer";
2217 env.add_explicit_layer(
2218 ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
2219 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2220 "regular_test_layer.json");
2221
2222 auto& layer_handle = env.get_test_layer(0);
2223 layer_handle.set_create_instance_callback([](TestLayer& layer) -> VkResult {
2224 uint32_t phys_dev_count = 0;
2225 VkResult res = layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, nullptr);
2226 if (res != VK_SUCCESS || phys_dev_count > 1) {
2227 return VK_ERROR_INITIALIZATION_FAILED; // expecting only a single physical device.
2228 }
2229 VkPhysicalDevice phys_dev{};
2230 res = layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, &phys_dev);
2231 if (res != VK_SUCCESS) {
2232 return VK_ERROR_INITIALIZATION_FAILED;
2233 }
2234 VkPhysicalDeviceProperties2 props2{};
2235 props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
2236 layer.instance_dispatch_table.GetPhysicalDeviceProperties2(phys_dev, &props2);
2237
2238 VkPhysicalDeviceFeatures2 features2{};
2239 features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
2240 layer.instance_dispatch_table.GetPhysicalDeviceFeatures2(phys_dev, &features2);
2241 return VK_SUCCESS;
2242 });
2243
2244 InstWrapper inst{env.vulkan_functions};
2245 inst.create_info.add_layer(regular_layer_name).set_api_version(1, 1, 0);
2246 inst.CheckCreate();
2247 }
2248
TEST(LayerCreateInstance,GetPhysicalDeviceProperties2KHR)2249 TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
2250 FrameworkEnvironment env;
2251 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA))
2252 .add_physical_device({})
2253 .add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
2254
2255 const char* regular_layer_name = "VK_LAYER_TestLayer";
2256 env.add_explicit_layer(
2257 ManifestLayer{}.add_layer(
2258 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2259 "regular_test_layer.json");
2260
2261 auto& layer_handle = env.get_test_layer(0);
2262 layer_handle.set_create_instance_callback([](TestLayer& layer) -> VkResult {
2263 uint32_t phys_dev_count = 1;
2264 VkPhysicalDevice phys_dev{};
2265 layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, &phys_dev);
2266
2267 VkPhysicalDeviceProperties2KHR props2{};
2268 props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
2269 layer.instance_dispatch_table.GetPhysicalDeviceProperties2KHR(phys_dev, &props2);
2270
2271 VkPhysicalDeviceFeatures2KHR features2{};
2272 features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
2273 layer.instance_dispatch_table.GetPhysicalDeviceFeatures2KHR(phys_dev, &features2);
2274 return VK_SUCCESS;
2275 });
2276
2277 InstWrapper inst{env.vulkan_functions};
2278 inst.create_info.add_layer(regular_layer_name).add_extension("VK_KHR_get_physical_device_properties2");
2279 inst.CheckCreate();
2280 }
2281
TEST(ExplicitLayers,MultipleLayersInSingleManifest)2282 TEST(ExplicitLayers, MultipleLayersInSingleManifest) {
2283 FrameworkEnvironment env;
2284 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2285
2286 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
2287 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
2288 const char* regular_layer_name_3 = "VK_LAYER_RegularLayer3";
2289 env.add_explicit_layer(TestLayerDetails(
2290 ManifestLayer{}
2291 .set_file_format_version({1, 0, 1})
2292 .add_layer(
2293 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2))
2294 .add_layer(
2295 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2))
2296 .add_layer(
2297 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_3).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2298 "multi_layer_manifest.json"));
2299
2300 auto layer_props = env.GetLayerProperties(3);
2301 ASSERT_TRUE(string_eq(regular_layer_name_1, layer_props[0].layerName));
2302 ASSERT_TRUE(string_eq(regular_layer_name_2, layer_props[1].layerName));
2303 ASSERT_TRUE(string_eq(regular_layer_name_3, layer_props[2].layerName));
2304 }
2305
TEST(ExplicitLayers,WrapObjects)2306 TEST(ExplicitLayers, WrapObjects) {
2307 FrameworkEnvironment env;
2308 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device("physical_device_0");
2309
2310 const char* wrap_objects_name = "VK_LAYER_LUNARG_wrap_objects";
2311 env.add_explicit_layer(ManifestLayer{}.add_layer(
2312 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
2313 "wrap_objects_layer.json");
2314
2315 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
2316 env.add_explicit_layer(
2317 ManifestLayer{}.add_layer(
2318 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2319 "regular_layer_1.json");
2320
2321 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
2322 env.add_explicit_layer(
2323 ManifestLayer{}.add_layer(
2324 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2325 "regular_layer_2.json");
2326
2327 { // just the wrap layer
2328 InstWrapper inst{env.vulkan_functions};
2329 inst.create_info.add_layer(wrap_objects_name);
2330 inst.CheckCreate();
2331 VkPhysicalDevice phys_dev = inst.GetPhysDev();
2332
2333 DeviceWrapper dev{inst};
2334 dev.CheckCreate(phys_dev);
2335 }
2336 { // wrap layer first
2337 InstWrapper inst{env.vulkan_functions};
2338 inst.create_info.add_layer(wrap_objects_name).add_layer(regular_layer_name_1);
2339 inst.CheckCreate();
2340 VkPhysicalDevice phys_dev = inst.GetPhysDev();
2341
2342 DeviceWrapper dev{inst};
2343 dev.CheckCreate(phys_dev);
2344 }
2345 { // wrap layer last
2346 InstWrapper inst{env.vulkan_functions};
2347 inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name);
2348 inst.CheckCreate();
2349 VkPhysicalDevice phys_dev = inst.GetPhysDev();
2350
2351 DeviceWrapper dev{inst};
2352 dev.CheckCreate(phys_dev);
2353 }
2354 { // wrap layer last
2355 InstWrapper inst{env.vulkan_functions};
2356 inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name).add_layer(regular_layer_name_2);
2357 inst.CheckCreate();
2358 VkPhysicalDevice phys_dev = inst.GetPhysDev();
2359
2360 DeviceWrapper dev{inst};
2361 dev.CheckCreate(phys_dev);
2362 }
2363 }
2364
TEST(ExplicitLayers,VkLayerPathEnvVar)2365 TEST(ExplicitLayers, VkLayerPathEnvVar) {
2366 FrameworkEnvironment env;
2367 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2368
2369 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
2370 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
2371 env.add_explicit_layer(
2372 TestLayerDetails(
2373 ManifestLayer{}.add_layer(
2374 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2375 "regular_layer_1.json")
2376 .set_discovery_type(ManifestDiscoveryType::env_var)
2377 .set_is_dir(false));
2378
2379 InstWrapper inst(env.vulkan_functions);
2380 inst.create_info.add_layer(regular_layer_name_1);
2381 inst.CheckCreate();
2382 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2383 EXPECT_TRUE(string_eq(layer_props.at(0).layerName, regular_layer_name_1));
2384 }
2385
TEST(ExplicitLayers,VkLayerPathEnvVarContainsMultipleFilepaths)2386 TEST(ExplicitLayers, VkLayerPathEnvVarContainsMultipleFilepaths) {
2387 FrameworkEnvironment env;
2388 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2389
2390 // verify layers load successfully when setting VK_LAYER_PATH to multiple full filepaths
2391 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
2392 env.add_explicit_layer(
2393 TestLayerDetails(
2394 ManifestLayer{}.add_layer(
2395 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2396 "regular_layer_1.json")
2397 .set_discovery_type(ManifestDiscoveryType::env_var)
2398 .set_is_dir(false));
2399
2400 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
2401 env.add_explicit_layer(
2402 TestLayerDetails(
2403 ManifestLayer{}.add_layer(
2404 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2405 "regular_layer_2.json")
2406 .set_discovery_type(ManifestDiscoveryType::env_var)
2407 .set_is_dir(false));
2408
2409 InstWrapper inst(env.vulkan_functions);
2410 inst.create_info.add_layer(regular_layer_name_1);
2411 inst.create_info.add_layer(regular_layer_name_2);
2412 inst.CheckCreate();
2413 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2414 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props));
2415 }
2416
TEST(ExplicitLayers,VkLayerPathEnvVarIsDirectory)2417 TEST(ExplicitLayers, VkLayerPathEnvVarIsDirectory) {
2418 FrameworkEnvironment env;
2419 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2420
2421 // verify layers load successfully when setting VK_LAYER_PATH to a directory
2422 const char* regular_layer_name_1 = "VK_LAYER_RegularLayer1";
2423 env.add_explicit_layer(
2424 TestLayerDetails(
2425 ManifestLayer{}.add_layer(
2426 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2427 "regular_layer_1.json")
2428 .set_discovery_type(ManifestDiscoveryType::env_var));
2429
2430 const char* regular_layer_name_2 = "VK_LAYER_RegularLayer2";
2431 env.add_explicit_layer(
2432 TestLayerDetails(
2433 ManifestLayer{}.add_layer(
2434 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2435 "regular_layer_2.json")
2436 .set_discovery_type(ManifestDiscoveryType::env_var));
2437
2438 InstWrapper inst(env.vulkan_functions);
2439 inst.create_info.add_layer(regular_layer_name_1);
2440 inst.create_info.add_layer(regular_layer_name_2);
2441 inst.CheckCreate();
2442 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2443 EXPECT_TRUE(check_permutation({regular_layer_name_1, regular_layer_name_2}, layer_props));
2444 }
2445
TEST(ExplicitLayers,DuplicateLayersInVK_LAYER_PATH)2446 TEST(ExplicitLayers, DuplicateLayersInVK_LAYER_PATH) {
2447 FrameworkEnvironment env;
2448 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2449
2450 // verify layer loads successfully when setting VK_LAYER_PATH to a full filepath
2451 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
2452 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2453 .set_name(same_layer_name_1)
2454 .set_description("actually_layer_1")
2455 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2456 "regular_layer_1.json")
2457 // use override folder as just a folder and manually set the VK_LAYER_PATH env-var to it
2458 .set_discovery_type(ManifestDiscoveryType::override_folder)
2459 .set_is_dir(true));
2460 auto& layer1 = env.get_test_layer(0);
2461 layer1.set_description("actually_layer_1");
2462 layer1.set_make_spurious_log_in_create_instance("actually_layer_1");
2463 env.env_var_vk_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location());
2464
2465 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2466 .set_name(same_layer_name_1)
2467 .set_description("actually_layer_2")
2468 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2469 "regular_layer_1.json")
2470 .set_discovery_type(ManifestDiscoveryType::env_var)
2471 .set_is_dir(true));
2472 auto& layer2 = env.get_test_layer(1);
2473 layer2.set_description("actually_layer_2");
2474 layer2.set_make_spurious_log_in_create_instance("actually_layer_2");
2475
2476 auto layer_props = env.GetLayerProperties(2);
2477 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName));
2478 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName));
2479 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2480 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2481 {
2482 InstWrapper inst{env.vulkan_functions};
2483 inst.create_info.add_layer(same_layer_name_1);
2484 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2485 inst.CheckCreate();
2486 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2487 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2488 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2489 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2490 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2491 }
2492 env.debug_log.clear();
2493
2494 {
2495 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", same_layer_name_1};
2496 InstWrapper inst{env.vulkan_functions};
2497 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2498 inst.CheckCreate();
2499 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2500 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2501 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2502 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2503 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2504 }
2505 env.debug_log.clear();
2506
2507 {
2508 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", same_layer_name_1};
2509 InstWrapper inst{env.vulkan_functions};
2510 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2511 inst.CheckCreate();
2512 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2513 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2514 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2515 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2516 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2517 }
2518 env.debug_log.clear();
2519 }
2520
TEST(ExplicitLayers,DuplicateLayersInVK_ADD_LAYER_PATH)2521 TEST(ExplicitLayers, DuplicateLayersInVK_ADD_LAYER_PATH) {
2522 FrameworkEnvironment env;
2523 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2524
2525 const char* same_layer_name_1 = "VK_LAYER_RegularLayer1";
2526 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2527 .set_name(same_layer_name_1)
2528 .set_description("actually_layer_1")
2529 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2530 "regular_layer_1.json")
2531 // use override folder as just a folder and manually set the VK_ADD_LAYER_PATH env-var to it
2532 .set_discovery_type(ManifestDiscoveryType::override_folder)
2533 .set_is_dir(true));
2534 auto& layer1 = env.get_test_layer(0);
2535 layer1.set_description("actually_layer_1");
2536 layer1.set_make_spurious_log_in_create_instance("actually_layer_1");
2537 env.add_env_var_vk_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location());
2538
2539 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2540 .set_name(same_layer_name_1)
2541 .set_description("actually_layer_2")
2542 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2543 "regular_layer_1.json")
2544 .set_discovery_type(ManifestDiscoveryType::add_env_var)
2545 .set_is_dir(true));
2546 auto& layer2 = env.get_test_layer(1);
2547 layer2.set_description("actually_layer_2");
2548 layer2.set_make_spurious_log_in_create_instance("actually_layer_2");
2549
2550 auto layer_props = env.GetLayerProperties(2);
2551 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[0].layerName));
2552 ASSERT_TRUE(string_eq(same_layer_name_1, layer_props[1].layerName));
2553 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2554 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2555 {
2556 InstWrapper inst{env.vulkan_functions};
2557 inst.create_info.add_layer(same_layer_name_1);
2558 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2559 inst.CheckCreate();
2560 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2561 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2562 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2563 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2564 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2565 }
2566 env.debug_log.clear();
2567
2568 {
2569 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", same_layer_name_1};
2570 InstWrapper inst{env.vulkan_functions};
2571 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2572 inst.CheckCreate();
2573 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2574 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2575 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2576 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2577 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2578 }
2579 env.debug_log.clear();
2580
2581 {
2582 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", same_layer_name_1};
2583 InstWrapper inst{env.vulkan_functions};
2584 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2585 inst.CheckCreate();
2586 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2587 ASSERT_TRUE(string_eq(same_layer_name_1, enabled_layer_props.at(0).layerName));
2588 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props.at(0).description));
2589 ASSERT_TRUE(env.debug_log.find("actually_layer_1"));
2590 ASSERT_FALSE(env.debug_log.find("actually_layer_2"));
2591 }
2592 env.debug_log.clear();
2593 }
2594
TEST(ExplicitLayers,CorrectOrderOfEnvVarEnabledLayers)2595 TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayers) {
2596 FrameworkEnvironment env;
2597 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2598
2599 const char* layer_name_1 = "VK_LAYER_RegularLayer1";
2600 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2601 .set_name(layer_name_1)
2602 .set_description("actually_layer_1")
2603 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2604 "regular_layer_1.json")
2605 .set_discovery_type(ManifestDiscoveryType::env_var)
2606 .set_is_dir(true));
2607 auto& layer1 = env.get_test_layer(0);
2608 layer1.set_description("actually_layer_1");
2609
2610 const char* layer_name_2 = "VK_LAYER_RegularLayer2";
2611 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2612 .set_name(layer_name_2)
2613 .set_description("actually_layer_2")
2614 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2615 "regular_layer_2.json")
2616 .set_discovery_type(ManifestDiscoveryType::env_var)
2617 .set_is_dir(true));
2618 auto& layer2 = env.get_test_layer(1);
2619 layer2.set_description("actually_layer_2");
2620
2621 auto layer_props = env.GetLayerProperties(2);
2622 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName));
2623 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName));
2624 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2625 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2626 // 1 then 2
2627 {
2628 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
2629 inst_layers_env_var.add_to_list(layer_name_1);
2630 inst_layers_env_var.add_to_list(layer_name_2);
2631
2632 InstWrapper inst{env.vulkan_functions};
2633 inst.CheckCreate();
2634
2635 // Expect the env-var layer to be first
2636 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2637 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description));
2638 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description));
2639 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName));
2640 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName));
2641 }
2642 // 2 then 1
2643 {
2644 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
2645 inst_layers_env_var.add_to_list(layer_name_2);
2646 inst_layers_env_var.add_to_list(layer_name_1);
2647
2648 InstWrapper inst{env.vulkan_functions};
2649 inst.CheckCreate();
2650
2651 // Expect the env-var layer to be first
2652 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2653 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description));
2654 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description));
2655 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName));
2656 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName));
2657 }
2658 }
2659 // Test to make sure order layers are found in VK_LAYER_PATH is what decides which layer is loaded
TEST(ExplicitLayers,DuplicateLayersInVkLayerPath)2660 TEST(ExplicitLayers, DuplicateLayersInVkLayerPath) {
2661 FrameworkEnvironment env;
2662 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2663
2664 const char* layer_name = "VK_LAYER_RegularLayer1";
2665 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2666 .set_name(layer_name)
2667 .set_description("actually_layer_1")
2668 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2669 "layer.json")
2670 .set_discovery_type(ManifestDiscoveryType::env_var)
2671 .set_is_dir(true));
2672 auto& layer1 = env.get_test_layer(0);
2673 layer1.set_description("actually_layer_1");
2674
2675 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2676 .set_name(layer_name)
2677 .set_description("actually_layer_2")
2678 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2679 "layer.json")
2680 // putting it in a separate folder then manually adding the folder to VK_LAYER_PATH
2681 .set_discovery_type(ManifestDiscoveryType::override_folder)
2682 .set_is_dir(true));
2683 auto& layer2 = env.get_test_layer(1);
2684 layer2.set_description("actually_layer_2");
2685 env.env_var_vk_layer_paths.add_to_list(env.get_folder(ManifestLocation::override_layer).location().string());
2686
2687 auto layer_props = env.GetLayerProperties(2);
2688 ASSERT_TRUE(string_eq(layer_name, layer_props[0].layerName));
2689 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2690 ASSERT_TRUE(string_eq(layer_name, layer_props[1].layerName));
2691 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2692
2693 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
2694 inst_layers_env_var.add_to_list(layer_name);
2695
2696 InstWrapper inst{env.vulkan_functions};
2697 inst.CheckCreate();
2698
2699 // Expect the first layer added to be found
2700 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
2701 ASSERT_TRUE(string_eq(layer_name, enabled_layer_props[0].layerName));
2702 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description));
2703 }
2704
TEST(ExplicitLayers,CorrectOrderOfEnvVarEnabledLayersFromSystemLocations)2705 TEST(ExplicitLayers, CorrectOrderOfEnvVarEnabledLayersFromSystemLocations) {
2706 FrameworkEnvironment env;
2707 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2708
2709 const char* layer_name_1 = "VK_LAYER_RegularLayer1";
2710 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2711 .set_name(layer_name_1)
2712 .set_description("actually_layer_1")
2713 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2714 "regular_layer_1.json"));
2715 auto& layer1 = env.get_test_layer(0);
2716 layer1.set_description("actually_layer_1");
2717
2718 const char* layer_name_2 = "VK_LAYER_RegularLayer2";
2719 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2720 .set_name(layer_name_2)
2721 .set_description("actually_layer_2")
2722 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2723 "regular_layer_2.json"));
2724 auto& layer2 = env.get_test_layer(1);
2725 layer2.set_description("actually_layer_2");
2726
2727 auto layer_props = env.GetLayerProperties(2);
2728 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName));
2729 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName));
2730 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2731 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2732 // 1 then 2
2733 {
2734 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
2735 inst_layers_env_var.add_to_list(layer_name_1);
2736 inst_layers_env_var.add_to_list(layer_name_2);
2737
2738 InstWrapper inst{env.vulkan_functions};
2739 inst.CheckCreate();
2740 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2741 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description));
2742 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description));
2743 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName));
2744 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName));
2745 }
2746 // 2 then 1
2747 {
2748 EnvVarWrapper inst_layers_env_var{"VK_INSTANCE_LAYERS"};
2749 inst_layers_env_var.add_to_list(layer_name_2);
2750 inst_layers_env_var.add_to_list(layer_name_1);
2751
2752 InstWrapper inst{env.vulkan_functions};
2753 inst.CheckCreate();
2754
2755 // Expect the env-var layer to be first
2756 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2757 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description));
2758 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description));
2759 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName));
2760 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName));
2761 }
2762 }
2763
TEST(ExplicitLayers,CorrectOrderOfApplicationEnabledLayers)2764 TEST(ExplicitLayers, CorrectOrderOfApplicationEnabledLayers) {
2765 FrameworkEnvironment env;
2766 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2767
2768 const char* layer_name_1 = "VK_LAYER_RegularLayer1";
2769 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2770 .set_name(layer_name_1)
2771 .set_description("actually_layer_1")
2772 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2773 "regular_layer_1.json"));
2774 auto& layer1 = env.get_test_layer(0);
2775 layer1.set_description("actually_layer_1");
2776 layer1.set_make_spurious_log_in_create_instance("actually_layer_1");
2777
2778 const char* layer_name_2 = "VK_LAYER_RegularLayer2";
2779 env.add_explicit_layer(TestLayerDetails(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2780 .set_name(layer_name_2)
2781 .set_description("actually_layer_2")
2782 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
2783 "regular_layer_2.json"));
2784 auto& layer2 = env.get_test_layer(1);
2785 layer2.set_description("actually_layer_2");
2786 layer2.set_make_spurious_log_in_create_instance("actually_layer_2");
2787
2788 auto layer_props = env.GetLayerProperties(2);
2789 ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName));
2790 ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName));
2791 ASSERT_TRUE(string_eq(layer1.description.c_str(), layer_props[0].description));
2792 ASSERT_TRUE(string_eq(layer2.description.c_str(), layer_props[1].description));
2793
2794 // 1 then 2
2795 {
2796 InstWrapper inst{env.vulkan_functions};
2797 inst.create_info.add_layer(layer_name_1);
2798 inst.create_info.add_layer(layer_name_2);
2799 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2800 inst.CheckCreate();
2801
2802 // Expect the env-var layer to be first
2803 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2804 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[0].description));
2805 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[1].description));
2806 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[0].layerName));
2807 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[1].layerName));
2808 }
2809 // 2 then 1
2810 {
2811 InstWrapper inst{env.vulkan_functions};
2812 inst.create_info.add_layer(layer_name_2);
2813 inst.create_info.add_layer(layer_name_1);
2814 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
2815 inst.CheckCreate();
2816
2817 // Expect the env-var layer to be first
2818 auto enabled_layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 2);
2819 ASSERT_TRUE(string_eq(layer2.description.c_str(), enabled_layer_props[0].description));
2820 ASSERT_TRUE(string_eq(layer1.description.c_str(), enabled_layer_props[1].description));
2821 ASSERT_TRUE(string_eq(layer_name_2, enabled_layer_props[0].layerName));
2822 ASSERT_TRUE(string_eq(layer_name_1, enabled_layer_props[1].layerName));
2823 }
2824 }
2825
TEST(LayerExtensions,ImplicitNoAdditionalInstanceExtension)2826 TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
2827 FrameworkEnvironment env;
2828 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2829
2830 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
2831 const char* enable_env_var = "ENABLE_ME";
2832 const char* disable_env_var = "DISABLE_ME";
2833
2834 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2835 .set_name(implicit_layer_name)
2836 .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
2837 .set_disable_environment(disable_env_var)
2838 .set_enable_environment(enable_env_var)),
2839 "implicit_wrap_layer_no_ext.json");
2840
2841 auto layers = env.GetLayerProperties(1);
2842 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
2843
2844 // set enable env-var, layer should load
2845 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
2846 CheckLogForLayerString(env, implicit_layer_name, true);
2847
2848 auto extensions = env.GetInstanceExtensions(4);
2849 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
2850 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
2851 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
2852 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
2853
2854 // Make sure the extensions that are implemented only in the test layers is not present.
2855 ASSERT_FALSE(contains(extensions, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME));
2856 ASSERT_FALSE(contains(extensions, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
2857
2858 InstWrapper inst{env.vulkan_functions};
2859 inst.CheckCreate();
2860
2861 // Make sure all the function pointers are NULL as well
2862 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
2863 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
2864 }
2865
TEST(LayerExtensions,ImplicitDirDispModeInstanceExtension)2866 TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
2867 FrameworkEnvironment env;
2868 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2869
2870 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
2871 const char* enable_env_var = "ENABLE_ME";
2872 const char* disable_env_var = "DISABLE_ME";
2873
2874 env.add_implicit_layer(
2875 ManifestLayer{}.add_layer(
2876 ManifestLayer::LayerDescription{}
2877 .set_name(implicit_layer_name)
2878 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
2879 .set_disable_environment(disable_env_var)
2880 .set_enable_environment(enable_env_var)
2881 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})),
2882 "implicit_wrap_layer_dir_disp_mode.json");
2883
2884 auto layers = env.GetLayerProperties(1);
2885 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
2886
2887 // set enable env-var, layer should load
2888 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
2889 CheckLogForLayerString(env, implicit_layer_name, true);
2890
2891 auto extensions = env.GetInstanceExtensions(5);
2892 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
2893 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
2894 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
2895 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
2896 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME));
2897
2898 // Make sure the extensions that are implemented only in the test layers is not present.
2899 ASSERT_FALSE(contains(extensions, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
2900
2901 InstWrapper inst{env.vulkan_functions};
2902 inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
2903 inst.CheckCreate();
2904
2905 // Make sure only the appropriate function pointers are NULL as well
2906 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
2907 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
2908 }
2909
TEST(LayerExtensions,ImplicitDispSurfCountInstanceExtension)2910 TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
2911 FrameworkEnvironment env;
2912 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2913
2914 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
2915 const char* enable_env_var = "ENABLE_ME";
2916 const char* disable_env_var = "DISABLE_ME";
2917
2918 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
2919 .set_name(implicit_layer_name)
2920 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
2921 .set_disable_environment(disable_env_var)
2922 .set_enable_environment(enable_env_var)
2923 .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
2924 1,
2925 {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
2926 "implicit_wrap_layer_disp_surf_count.json");
2927
2928 auto layers = env.GetLayerProperties(1);
2929 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
2930
2931 // set enable env-var, layer should load
2932 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
2933 CheckLogForLayerString(env, implicit_layer_name, true);
2934
2935 auto extensions = env.GetInstanceExtensions(5);
2936 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
2937 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
2938 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
2939 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
2940 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
2941
2942 InstWrapper inst{env.vulkan_functions};
2943 inst.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
2944 inst.CheckCreate();
2945
2946 // Make sure only the appropriate function pointers are NULL as well
2947 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
2948 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
2949 }
2950
TEST(LayerExtensions,ImplicitBothInstanceExtensions)2951 TEST(LayerExtensions, ImplicitBothInstanceExtensions) {
2952 FrameworkEnvironment env;
2953 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2954
2955 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
2956 const char* enable_env_var = "ENABLE_ME";
2957 const char* disable_env_var = "DISABLE_ME";
2958
2959 env.add_implicit_layer(
2960 ManifestLayer{}.add_layer(
2961 ManifestLayer::LayerDescription{}
2962 .set_name(implicit_layer_name)
2963 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
2964 .set_disable_environment(disable_env_var)
2965 .set_enable_environment(enable_env_var)
2966 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})
2967 .add_instance_extension(
2968 {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
2969 "implicit_wrap_layer_both_inst.json");
2970
2971 auto layers = env.GetLayerProperties(1);
2972 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
2973
2974 // set enable env-var, layer should load
2975 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
2976 CheckLogForLayerString(env, implicit_layer_name, true);
2977
2978 auto extensions = env.GetInstanceExtensions(6);
2979 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
2980 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
2981 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
2982 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
2983 EXPECT_TRUE(string_eq(extensions.at(4).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME));
2984 EXPECT_TRUE(string_eq(extensions.at(5).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
2985
2986 InstWrapper inst{env.vulkan_functions};
2987 inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
2988 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
2989 inst.CheckCreate();
2990
2991 // Make sure only the appropriate function pointers are NULL as well
2992 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
2993 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
2994 }
2995
TEST(LayerExtensions,ExplicitNoAdditionalInstanceExtension)2996 TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
2997 FrameworkEnvironment env;
2998 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
2999
3000 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3001 env.add_explicit_layer(
3002 ManifestLayer{}.add_layer(
3003 ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
3004 "explicit_wrap_layer_no_ext.json");
3005
3006 auto layers = env.GetLayerProperties(1);
3007 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3008
3009 auto extensions = env.GetInstanceExtensions(4);
3010 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
3011 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
3012 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
3013 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
3014
3015 // Now query by layer name.
3016 ASSERT_NO_FATAL_FAILURE(env.GetInstanceExtensions(0, explicit_layer_name));
3017
3018 InstWrapper inst{env.vulkan_functions};
3019 inst.CheckCreate();
3020
3021 // Make sure all the function pointers are NULL as well
3022 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
3023 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3024 }
3025
TEST(LayerExtensions,ExplicitDirDispModeInstanceExtension)3026 TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
3027 FrameworkEnvironment env;
3028 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3029
3030 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3031 env.add_explicit_layer(
3032 ManifestLayer{}.add_layer(
3033 ManifestLayer::LayerDescription{}
3034 .set_name(explicit_layer_name)
3035 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
3036 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})),
3037 "explicit_wrap_layer_dir_disp_mode.json");
3038
3039 auto layers = env.GetLayerProperties(1);
3040 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3041
3042 auto extensions = env.GetInstanceExtensions(4);
3043 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
3044 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
3045 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
3046 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
3047
3048 // Now query by layer name.
3049 auto layer_extensions = env.GetInstanceExtensions(1, explicit_layer_name);
3050 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME));
3051
3052 InstWrapper inst1{env.vulkan_functions};
3053 inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
3054 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
3055
3056 // Make sure only the appropriate function pointers are NULL as well
3057 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
3058 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3059
3060 InstWrapper inst2{env.vulkan_functions};
3061 inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
3062 inst2.CheckCreate();
3063
3064 // Make sure only the appropriate function pointers are NULL as well
3065 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
3066 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3067 }
3068
TEST(LayerExtensions,ExplicitDispSurfCountInstanceExtension)3069 TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
3070 FrameworkEnvironment env;
3071 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3072
3073 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3074 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3075 .set_name(explicit_layer_name)
3076 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
3077 .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
3078 1,
3079 {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
3080 "explicit_wrap_layer_disp_surf_count.json");
3081
3082 auto layers = env.GetLayerProperties(1);
3083 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3084
3085 auto extensions = env.GetInstanceExtensions(4);
3086 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
3087 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
3088 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
3089 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
3090
3091 // Now query by layer name.
3092 auto layer_extensions = env.GetInstanceExtensions(1, explicit_layer_name);
3093 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
3094
3095 InstWrapper inst1{env.vulkan_functions};
3096 inst1.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
3097 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
3098
3099 // Make sure only the appropriate function pointers are NULL as well
3100 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
3101 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3102
3103 InstWrapper inst2{env.vulkan_functions};
3104 inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
3105 inst2.CheckCreate();
3106
3107 // Make sure only the appropriate function pointers are NULL as well
3108 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
3109 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3110 }
3111
TEST(LayerExtensions,ExplicitBothInstanceExtensions)3112 TEST(LayerExtensions, ExplicitBothInstanceExtensions) {
3113 FrameworkEnvironment env;
3114 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3115
3116 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3117 env.add_explicit_layer(
3118 ManifestLayer{}.add_layer(
3119 ManifestLayer::LayerDescription{}
3120 .set_name(explicit_layer_name)
3121 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
3122 .add_instance_extension({VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, 1, {"vkReleaseDisplayEXT"}})
3123 .add_instance_extension(
3124 {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
3125 "explicit_wrap_layer_both_inst.json");
3126
3127 auto layers = env.GetLayerProperties(1);
3128 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3129
3130 auto extensions = env.GetInstanceExtensions(4);
3131 EXPECT_TRUE(string_eq(extensions.at(0).extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
3132 EXPECT_TRUE(string_eq(extensions.at(1).extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
3133 EXPECT_TRUE(string_eq(extensions.at(2).extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME));
3134 EXPECT_TRUE(string_eq(extensions.at(3).extensionName, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME));
3135
3136 // Make sure the extensions still aren't present in this layer
3137 auto layer_extensions = env.GetInstanceExtensions(2, explicit_layer_name);
3138 EXPECT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME));
3139 EXPECT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME));
3140
3141 InstWrapper inst1{env.vulkan_functions};
3142 inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
3143 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
3144 inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
3145
3146 // Make sure only the appropriate function pointers are NULL as well
3147 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
3148 handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
3149
3150 InstWrapper inst2{env.vulkan_functions};
3151 inst2.create_info.add_layer(explicit_layer_name)
3152 .add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
3153 .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
3154 inst2.CheckCreate();
3155 VkPhysicalDevice phys_dev = inst2.GetPhysDev();
3156
3157 // Make sure only the appropriate function pointers are NULL as well
3158 handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
3159 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT pfnGetPhysicalDeviceSurfaceCapabilities2EXT =
3160 inst2.load("vkGetPhysicalDeviceSurfaceCapabilities2EXT");
3161 handle_assert_has_value(pfnGetPhysicalDeviceSurfaceCapabilities2EXT);
3162
3163 VkSurfaceCapabilities2EXT surf_caps{VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT};
3164
3165 // Call and then check a few things
3166 ASSERT_EQ(VK_SUCCESS, pfnGetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev, VK_NULL_HANDLE, &surf_caps));
3167 ASSERT_EQ(7U, surf_caps.minImageCount);
3168 ASSERT_EQ(12U, surf_caps.maxImageCount);
3169 ASSERT_EQ(365U, surf_caps.maxImageArrayLayers);
3170 }
3171
TEST(LayerExtensions,ImplicitNoAdditionalDeviceExtension)3172 TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
3173 FrameworkEnvironment env;
3174 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3175
3176 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3177 const char* enable_env_var = "ENABLE_ME";
3178 const char* disable_env_var = "DISABLE_ME";
3179
3180 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3181 .set_name(implicit_layer_name)
3182 .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
3183 .set_disable_environment(disable_env_var)
3184 .set_enable_environment(enable_env_var)),
3185 "implicit_wrap_layer_no_ext.json");
3186
3187 auto layers = env.GetLayerProperties(1);
3188 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
3189
3190 // set enable env-var, layer should load
3191 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
3192 CheckLogForLayerString(env, implicit_layer_name, true);
3193
3194 InstWrapper inst{env.vulkan_functions};
3195 inst.CheckCreate();
3196 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3197 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
3198
3199 // Device functions queried using vkGetInstanceProcAddr should be non-NULL since this could be available for any attached
3200 // physical device.
3201 PFN_vkTrimCommandPoolKHR pfn_vkTrimCommandPool = inst.load("vkTrimCommandPoolKHR");
3202 PFN_vkGetSwapchainStatusKHR pfn_vkGetSwapchainStatus = inst.load("vkGetSwapchainStatusKHR");
3203 PFN_vkSetDeviceMemoryPriorityEXT pfn_vkSetDeviceMemoryPriority = inst.load("vkSetDeviceMemoryPriorityEXT");
3204 handle_assert_has_value(pfn_vkTrimCommandPool);
3205 handle_assert_has_value(pfn_vkGetSwapchainStatus);
3206 handle_assert_has_value(pfn_vkSetDeviceMemoryPriority);
3207
3208 DeviceWrapper dev{inst};
3209 dev.CheckCreate(phys_dev);
3210
3211 // Query again after create device to make sure the value returned by vkGetInstanceProcAddr did not change
3212 PFN_vkTrimCommandPoolKHR pfn_vkTrimCommandPool2 = inst.load("vkTrimCommandPoolKHR");
3213 PFN_vkGetSwapchainStatusKHR pfn_vkGetSwapchainStatus2 = inst.load("vkGetSwapchainStatusKHR");
3214 PFN_vkSetDeviceMemoryPriorityEXT pfn_vkSetDeviceMemoryPriority2 = inst.load("vkSetDeviceMemoryPriorityEXT");
3215 ASSERT_EQ(pfn_vkTrimCommandPool, pfn_vkTrimCommandPool2);
3216 ASSERT_EQ(pfn_vkGetSwapchainStatus, pfn_vkGetSwapchainStatus2);
3217 ASSERT_EQ(pfn_vkSetDeviceMemoryPriority, pfn_vkSetDeviceMemoryPriority2);
3218
3219 // Make sure all the function pointers returned by vkGetDeviceProcAddr for non-enabled extensions are NULL
3220 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3221 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3222 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkSetDeviceMemoryPriorityEXT"));
3223
3224 // Even though the instance functions returned are non-NULL. They should not work if we haven't enabled the extensions.
3225 ASSERT_DEATH(pfn_vkTrimCommandPool(dev.dev, VK_NULL_HANDLE, 0), "");
3226 ASSERT_DEATH(pfn_vkGetSwapchainStatus(dev.dev, VK_NULL_HANDLE), "");
3227 ASSERT_DEATH(pfn_vkSetDeviceMemoryPriority(dev.dev, VK_NULL_HANDLE, 0.f), "");
3228 }
3229
TEST(LayerExtensions,ImplicitMaintenanceDeviceExtension)3230 TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
3231 FrameworkEnvironment env;
3232 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3233
3234 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3235 const char* enable_env_var = "ENABLE_ME";
3236 const char* disable_env_var = "DISABLE_ME";
3237
3238 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3239 .set_name(implicit_layer_name)
3240 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
3241 .set_disable_environment(disable_env_var)
3242 .set_enable_environment(enable_env_var)),
3243 "implicit_wrap_layer_maint.json");
3244
3245 auto layers = env.GetLayerProperties(1);
3246 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
3247
3248 // set enable env-var, layer should load
3249 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
3250 CheckLogForLayerString(env, implicit_layer_name, true);
3251
3252 InstWrapper inst{env.vulkan_functions};
3253 inst.CheckCreate();
3254 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3255 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1);
3256 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
3257
3258 DeviceWrapper dev{inst};
3259 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
3260 dev.CheckCreate(phys_dev);
3261
3262 // Make sure only the appropriate function pointers are NULL as well
3263 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3264 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3265 }
3266
TEST(LayerExtensions,ImplicitPresentImageDeviceExtension)3267 TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) {
3268 FrameworkEnvironment env;
3269 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3270
3271 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3272 const char* enable_env_var = "ENABLE_ME";
3273 const char* disable_env_var = "DISABLE_ME";
3274
3275 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3276 .set_name(implicit_layer_name)
3277 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
3278 .set_disable_environment(disable_env_var)
3279 .set_enable_environment(enable_env_var)),
3280 "implicit_wrap_layer_pres.json");
3281
3282 auto layers = env.GetLayerProperties(1);
3283 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
3284
3285 // set enable env-var, layer should load
3286 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
3287 CheckLogForLayerString(env, implicit_layer_name, true);
3288
3289 InstWrapper inst{env.vulkan_functions};
3290 inst.CheckCreate();
3291 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3292 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 1);
3293 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
3294
3295 DeviceWrapper dev{inst};
3296 dev.create_info.add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
3297 dev.CheckCreate(phys_dev);
3298
3299 // Make sure only the appropriate function pointers are NULL as well
3300 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3301 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3302 }
3303
TEST(LayerExtensions,ImplicitBothDeviceExtensions)3304 TEST(LayerExtensions, ImplicitBothDeviceExtensions) {
3305 FrameworkEnvironment env;
3306 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3307
3308 const char* implicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3309 const char* enable_env_var = "ENABLE_ME";
3310 const char* disable_env_var = "DISABLE_ME";
3311
3312 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3313 .set_name(implicit_layer_name)
3314 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
3315 .set_disable_environment(disable_env_var)
3316 .set_enable_environment(enable_env_var)),
3317 "implicit_wrap_layer_both_dev.json");
3318
3319 auto layers = env.GetLayerProperties(1);
3320 ASSERT_TRUE(string_eq(layers[0].layerName, implicit_layer_name));
3321
3322 // set enable env-var, layer should load
3323 EnvVarWrapper wrap_enable_env_var{enable_env_var, "1"};
3324 CheckLogForLayerString(env, implicit_layer_name, true);
3325
3326 InstWrapper inst{env.vulkan_functions};
3327 inst.CheckCreate();
3328 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3329 auto device_extensions = inst.EnumerateDeviceExtensions(phys_dev, 2);
3330 ASSERT_TRUE(string_eq(device_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
3331 ASSERT_TRUE(string_eq(device_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
3332
3333 DeviceWrapper dev{inst};
3334 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME).add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
3335 dev.CheckCreate(phys_dev);
3336
3337 // Make sure only the appropriate function pointers are NULL as well
3338 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3339 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3340 }
3341
TEST(LayerExtensions,ExplicitNoAdditionalDeviceExtension)3342 TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
3343 FrameworkEnvironment env;
3344 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3345
3346 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3347 env.add_explicit_layer(
3348 ManifestLayer{}.add_layer(
3349 ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
3350 "explicit_wrap_layer_no_ext.json");
3351
3352 auto layers = env.GetLayerProperties(1);
3353 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3354
3355 InstWrapper inst{env.vulkan_functions};
3356 inst.create_info.add_layer(explicit_layer_name);
3357 inst.CheckCreate();
3358 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3359
3360 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
3361 ASSERT_NO_FATAL_FAILURE(inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 0));
3362
3363 DeviceWrapper dev{inst};
3364 dev.CheckCreate(phys_dev);
3365
3366 // Make sure all the function pointers are NULL as well
3367 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3368 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3369 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkSetDeviceMemoryPriorityEXT"));
3370 }
3371
TEST(LayerExtensions,ExplicitMaintenanceDeviceExtension)3372 TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
3373 FrameworkEnvironment env;
3374 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3375
3376 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3377 env.add_explicit_layer(
3378 ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3379 .set_name(explicit_layer_name)
3380 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
3381 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
3382 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})),
3383 "explicit_wrap_layer_maint.json");
3384
3385 auto layers = env.GetLayerProperties(1);
3386 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3387
3388 InstWrapper inst{env.vulkan_functions};
3389 inst.create_info.add_layer(explicit_layer_name);
3390 inst.CheckCreate();
3391 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3392
3393 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
3394 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 1);
3395 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
3396
3397 DeviceWrapper dev{inst};
3398 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
3399 dev.CheckCreate(phys_dev);
3400
3401 // Make sure only the appropriate function pointers are NULL as well
3402 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3403 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3404 }
3405
TEST(LayerExtensions,ExplicitPresentImageDeviceExtension)3406 TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) {
3407 FrameworkEnvironment env;
3408 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3409
3410 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3411 env.add_explicit_layer(
3412 ManifestLayer{}.add_layer(
3413 ManifestLayer::LayerDescription{}
3414 .set_name(explicit_layer_name)
3415 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
3416 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
3417 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})),
3418 "explicit_wrap_layer_pres.json");
3419
3420 auto layers = env.GetLayerProperties(1);
3421 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3422
3423 InstWrapper inst{env.vulkan_functions};
3424 inst.create_info.add_layer(explicit_layer_name);
3425 inst.CheckCreate();
3426 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3427
3428 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
3429 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 1);
3430 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
3431
3432 DeviceWrapper dev{inst};
3433 dev.create_info.add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
3434 dev.CheckCreate(phys_dev);
3435
3436 // Make sure only the appropriate function pointers are NULL as well
3437 handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3438 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
3439 }
3440
TEST(LayerExtensions,ExplicitBothDeviceExtensions)3441 TEST(LayerExtensions, ExplicitBothDeviceExtensions) {
3442 FrameworkEnvironment env;
3443 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
3444
3445 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3446 env.add_explicit_layer(
3447 ManifestLayer{}.add_layer(
3448 ManifestLayer::LayerDescription{}
3449 .set_name(explicit_layer_name)
3450 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
3451 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
3452 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})
3453 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})),
3454 "explicit_wrap_layer_both_dev.json");
3455
3456 auto layers = env.GetLayerProperties(1);
3457 ASSERT_TRUE(string_eq(layers[0].layerName, explicit_layer_name));
3458
3459 InstWrapper inst{env.vulkan_functions};
3460 inst.create_info.add_layer(explicit_layer_name);
3461 inst.CheckCreate();
3462 VkPhysicalDevice phys_dev = inst.GetPhysDev();
3463 handle_assert_has_value(phys_dev);
3464
3465 ASSERT_NO_FATAL_FAILURE(inst.EnumerateDeviceExtensions(phys_dev, 0));
3466 auto layer_extensions = inst.EnumerateLayerDeviceExtensions(phys_dev, explicit_layer_name, 2);
3467 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
3468 ASSERT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
3469
3470 DeviceWrapper dev{inst};
3471 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME).add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
3472 dev.CheckCreate(phys_dev);
3473
3474 // Make sure only the appropriate function pointers are NULL as well
3475 handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkTrimCommandPoolKHR"));
3476
3477 PFN_vkGetSwapchainStatusKHR gipa_pfnGetSwapchainStatusKHR = inst.load("vkGetSwapchainStatusKHR");
3478 PFN_vkGetSwapchainStatusKHR gdpa_pfnGetSwapchainStatusKHR = dev.load("vkGetSwapchainStatusKHR");
3479 handle_assert_has_value(gipa_pfnGetSwapchainStatusKHR);
3480 handle_assert_has_value(gdpa_pfnGetSwapchainStatusKHR);
3481
3482 // Make sure both versions (from vkGetInstanceProcAddr and vkGetDeviceProcAddr) return the same value.
3483 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, gipa_pfnGetSwapchainStatusKHR(dev.dev, VK_NULL_HANDLE));
3484 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, gdpa_pfnGetSwapchainStatusKHR(dev.dev, VK_NULL_HANDLE));
3485 }
3486
TEST(TestLayers,ExplicitlyEnableImplicitLayer)3487 TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
3488 FrameworkEnvironment env;
3489 uint32_t api_version = VK_API_VERSION_1_2;
3490 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
3491 .set_icd_api_version(api_version)
3492 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
3493
3494 const char* regular_layer_name = "VK_LAYER_TestLayer1";
3495 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3496 .set_name(regular_layer_name)
3497 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3498 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
3499 .set_disable_environment("DisableMeIfYouCan")),
3500 "regular_test_layer.json");
3501 { // 1.1 instance
3502 InstWrapper inst{env.vulkan_functions};
3503 inst.create_info.add_layer(regular_layer_name);
3504 inst.create_info.set_api_version(1, 1, 0);
3505 inst.CheckCreate();
3506 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3507 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3508 }
3509 { // 1.2 instance
3510 InstWrapper inst{env.vulkan_functions};
3511 inst.create_info.add_layer(regular_layer_name);
3512 inst.create_info.set_api_version(1, 2, 0);
3513 inst.CheckCreate();
3514 inst.GetActiveLayers(inst.GetPhysDev(), 1);
3515 }
3516 }
3517
TEST(TestLayers,NewerInstanceVersionThanImplicitLayer)3518 TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
3519 FrameworkEnvironment env;
3520 uint32_t api_version = VK_API_VERSION_1_2;
3521 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
3522 .set_icd_api_version(api_version)
3523 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
3524
3525 const char* regular_layer_name = "VK_LAYER_TestLayer1";
3526 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3527 .set_name(regular_layer_name)
3528 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3529 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
3530 .set_disable_environment("DisableMeIfYouCan")),
3531 "regular_test_layer.json");
3532 { // global functions
3533 auto layer_props = env.GetLayerProperties(1);
3534 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
3535 }
3536 { // 1.1 instance - should find the implicit layer
3537 InstWrapper inst{env.vulkan_functions};
3538 inst.create_info.set_api_version(1, 1, 0);
3539 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
3540 inst.CheckCreate();
3541 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
3542 env.debug_log.clear();
3543 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3544 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3545 }
3546 { // 1.2 instance -- instance layer should be found
3547 InstWrapper inst{env.vulkan_functions};
3548 inst.create_info.set_api_version(1, 2, 0);
3549 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
3550 inst.CheckCreate();
3551 EXPECT_TRUE(env.debug_log.find(std::string("Insert instance layer \"") + regular_layer_name));
3552 env.debug_log.clear();
3553
3554 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3555 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3556 }
3557 }
3558
TEST(TestLayers,ImplicitLayerPre10APIVersion)3559 TEST(TestLayers, ImplicitLayerPre10APIVersion) {
3560 FrameworkEnvironment env;
3561 uint32_t api_version = VK_API_VERSION_1_2;
3562 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
3563 .set_icd_api_version(api_version)
3564 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
3565
3566 const char* regular_layer_name = "VK_LAYER_TestLayer1";
3567 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3568 .set_name(regular_layer_name)
3569 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3570 .set_api_version(VK_MAKE_API_VERSION(0, 0, 1, 0))
3571 .set_disable_environment("DisableMeIfYouCan")),
3572 "regular_test_layer.json");
3573 { // global functions
3574 auto layer_props = env.GetLayerProperties(1);
3575 EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
3576 }
3577 { // 1.0 instance
3578 DebugUtilsLogger log;
3579 InstWrapper inst{env.vulkan_functions};
3580 inst.create_info.set_api_version(1, 0, 0);
3581 FillDebugUtilsCreateDetails(inst.create_info, log);
3582 inst.CheckCreate();
3583 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name));
3584 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3585 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3586 }
3587 { // 1.1 instance
3588 DebugUtilsLogger log;
3589 InstWrapper inst{env.vulkan_functions};
3590 inst.create_info.set_api_version(1, 1, 0);
3591 FillDebugUtilsCreateDetails(inst.create_info, log);
3592 inst.CheckCreate();
3593 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name));
3594 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3595 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3596 }
3597 { // 1.2 instance
3598 DebugUtilsLogger log;
3599 InstWrapper inst{env.vulkan_functions};
3600 inst.create_info.set_api_version(1, 2, 0);
3601 FillDebugUtilsCreateDetails(inst.create_info, log);
3602 inst.CheckCreate();
3603 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name));
3604 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3605 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3606 }
3607 { // application sets its API version to 0
3608 DebugUtilsLogger log;
3609 InstWrapper inst{env.vulkan_functions};
3610 inst.create_info.set_api_version(0);
3611 FillDebugUtilsCreateDetails(inst.create_info, log);
3612 inst.CheckCreate();
3613 EXPECT_TRUE(log.find(std::string("Insert instance layer \"") + regular_layer_name));
3614 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
3615 ASSERT_TRUE(string_eq(regular_layer_name, layer_props.at(0).layerName));
3616 }
3617 }
3618
3619 // Verify that VK_INSTANCE_LAYERS work. To test this, make sure that an explicit layer does not affect an instance until
3620 // it is set with VK_INSTANCE_LAYERS
TEST(TestLayers,InstEnvironEnableExplicitLayer)3621 TEST(TestLayers, InstEnvironEnableExplicitLayer) {
3622 FrameworkEnvironment env;
3623 uint32_t api_version = VK_API_VERSION_1_2;
3624 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
3625 .set_icd_api_version(api_version)
3626 .add_physical_device(PhysicalDevice{}.set_api_version(api_version).finish());
3627
3628 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
3629 env.add_explicit_layer(
3630 ManifestLayer{}.add_layer(
3631 ManifestLayer::LayerDescription{}
3632 .set_name(explicit_layer_name)
3633 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
3634 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
3635 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})
3636 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})),
3637 "explicit_wrap_layer_both_dev.json");
3638
3639 // First, test an instance/device without the layer forced on. The extensions shouldn't be present and
3640 // the function pointers should be NULL.
3641 InstWrapper inst1{env.vulkan_functions};
3642 inst1.CheckCreate();
3643 VkPhysicalDevice phys_dev1 = inst1.GetPhysDev();
3644
3645 ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0));
3646
3647 // Create a device and query the function pointers
3648 DeviceWrapper dev1{inst1};
3649 dev1.CheckCreate(phys_dev1);
3650 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolBefore = dev1.load("vkTrimCommandPoolKHR");
3651 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusBefore = dev1.load("vkGetSwapchainStatusKHR");
3652 handle_assert_null(pfn_TrimCommandPoolBefore);
3653 handle_assert_null(pfn_GetSwapchainStatusBefore);
3654
3655 // Now setup the instance layer
3656 EnvVarWrapper instance_layers_env_var{"VK_INSTANCE_LAYERS", explicit_layer_name};
3657
3658 // Now, test an instance/device with the layer forced on. The extensions should be present and
3659 // the function pointers should be valid.
3660 InstWrapper inst2{env.vulkan_functions};
3661 inst2.CheckCreate();
3662 VkPhysicalDevice phys_dev2 = inst2.GetPhysDev();
3663
3664 auto layer_extensions = inst2.EnumerateLayerDeviceExtensions(phys_dev2, explicit_layer_name, 2);
3665 ASSERT_TRUE(string_eq(layer_extensions.at(0).extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
3666 ASSERT_TRUE(string_eq(layer_extensions.at(1).extensionName, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME));
3667
3668 DeviceWrapper dev2{inst2};
3669 dev2.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)
3670 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
3671 dev2.CheckCreate(phys_dev2);
3672
3673 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev2.load("vkTrimCommandPoolKHR");
3674 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev2.load("vkGetSwapchainStatusKHR");
3675 handle_assert_has_value(pfn_TrimCommandPoolAfter);
3676 handle_assert_has_value(pfn_GetSwapchainStatusAfter);
3677
3678 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, pfn_GetSwapchainStatusAfter(dev2.dev, VK_NULL_HANDLE));
3679 }
3680
3681 // Verify that VK_LOADER_LAYERS_ENABLE work. To test this, make sure that an explicit layer does not affect an instance until
3682 // it is set with VK_LOADER_LAYERS_ENABLE
TEST(TestLayers,EnvironLayerEnableExplicitLayer)3683 TEST(TestLayers, EnvironLayerEnableExplicitLayer) {
3684 FrameworkEnvironment env;
3685 uint32_t api_version = VK_API_VERSION_1_2;
3686 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, api_version))
3687 .set_icd_api_version(api_version)
3688 .add_physical_device(PhysicalDevice{});
3689
3690 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
3691 const char* explicit_json_name_1 = "First_layer.json";
3692 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3693 .set_name(explicit_layer_name_1)
3694 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3695 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3696 explicit_json_name_1);
3697
3698 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer";
3699 const char* explicit_json_name_2 = "Second_layer.json";
3700 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3701 .set_name(explicit_layer_name_2)
3702 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3703 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3704 explicit_json_name_2);
3705
3706 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_second_test_layer";
3707 const char* explicit_json_name_3 = "second_test_layer.json";
3708 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3709 .set_name(explicit_layer_name_3)
3710 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3711 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3712 explicit_json_name_3);
3713
3714 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"};
3715
3716 // First, test an instance/device without the layer forced on.
3717 InstWrapper inst1{env.vulkan_functions};
3718 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log);
3719 inst1.CheckCreate();
3720
3721 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3722 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3723 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3724 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3725 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3726 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3727 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3728 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3729 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3730 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3731 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3732 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3733
3734 // Now force on one layer with its full name
3735 // ------------------------------------------
3736 env.debug_log.clear();
3737 layers_enable_env_var.set_new_value(explicit_layer_name_1);
3738
3739 InstWrapper inst2{env.vulkan_functions};
3740 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log);
3741 inst2.CheckCreate();
3742
3743 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3744 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3745 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3746 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3747 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3748 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3749 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3750 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3751 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3752 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3753 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3754 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3755
3756 // Match prefix
3757 // ------------------------------------------
3758 env.debug_log.clear();
3759 layers_enable_env_var.set_new_value("VK_LAYER_LUNARG_*");
3760
3761 InstWrapper inst3{env.vulkan_functions};
3762 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log);
3763 inst3.CheckCreate();
3764
3765 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3766 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3767 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3768 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3769 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3770 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3771 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3772 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3773 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3774 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3775 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3776 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3777
3778 // Match suffix
3779 // ------------------------------------------
3780 env.debug_log.clear();
3781 layers_enable_env_var.set_new_value("*Second_layer");
3782
3783 InstWrapper inst4{env.vulkan_functions};
3784 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log);
3785 inst4.CheckCreate();
3786
3787 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3788 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3789 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3790 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3791 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3792 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3793 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3794 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3795 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3796 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3797 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3798 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3799
3800 // Match substring
3801 // ------------------------------------------
3802 env.debug_log.clear();
3803 layers_enable_env_var.set_new_value("*Second*");
3804
3805 InstWrapper inst5{env.vulkan_functions};
3806 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log);
3807 inst5.CheckCreate();
3808
3809 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3810 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3811 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3812 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3813 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3814 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3815 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3816 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3817 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3818 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3819 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3820 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3821
3822 // Match all with star '*'
3823 // ------------------------------------------
3824 env.debug_log.clear();
3825 layers_enable_env_var.set_new_value("*");
3826
3827 InstWrapper inst6{env.vulkan_functions};
3828 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log);
3829 inst6.CheckCreate();
3830
3831 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3832 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3833 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3834 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3835 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3836 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3837 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3838 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3839 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3840 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3841 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3842 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3843
3844 // Match all with special name
3845 // ------------------------------------------
3846 env.debug_log.clear();
3847 layers_enable_env_var.set_new_value("~all~");
3848
3849 InstWrapper inst7{env.vulkan_functions};
3850 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log);
3851 inst7.CheckCreate();
3852
3853 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3854 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3855 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3856 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3857 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3858 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3859 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3860 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3861 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3862 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3863 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3864 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3865 }
3866
3867 // Verify that VK_LOADER_LAYERS_DISABLE work. To test this, make sure that an explicit layer does not affect an instance until
3868 // it is set with VK_LOADER_LAYERS_DISABLE
TEST(TestLayers,EnvironLayerDisableExplicitLayer)3869 TEST(TestLayers, EnvironLayerDisableExplicitLayer) {
3870 FrameworkEnvironment env;
3871 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
3872 .set_icd_api_version(VK_API_VERSION_1_2)
3873 .add_physical_device(PhysicalDevice{});
3874
3875 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
3876 const char* explicit_json_name_1 = "First_layer.json";
3877 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3878 .set_name(explicit_layer_name_1)
3879 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3880 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3881 explicit_json_name_1);
3882
3883 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer";
3884 const char* explicit_json_name_2 = "Second_layer.json";
3885 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3886 .set_name(explicit_layer_name_2)
3887 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3888 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3889 explicit_json_name_2);
3890
3891 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer";
3892 const char* explicit_json_name_3 = "Second_test_layer.json";
3893 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
3894 .set_name(explicit_layer_name_3)
3895 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
3896 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
3897 explicit_json_name_3);
3898 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"};
3899
3900 // First, test an instance/device without the layer forced on.
3901 InstWrapper inst1{env.vulkan_functions};
3902 inst1.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
3903 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log);
3904 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate());
3905
3906 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3907 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3908 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3909 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3910 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3911 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3912 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3913 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3914 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3915 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3916 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3917 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3918
3919 // Now force on one layer with its full name
3920 // ------------------------------------------
3921 env.debug_log.clear();
3922 layers_disable_env_var.set_new_value(explicit_layer_name_1);
3923
3924 InstWrapper inst2{env.vulkan_functions};
3925 inst2.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
3926 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log);
3927 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
3928
3929 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3930 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3931 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3932 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3933 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3934 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3935 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3936 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3937 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3938 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3939 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3940 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3941
3942 // Match prefix
3943 // ------------------------------------------
3944 env.debug_log.clear();
3945 layers_disable_env_var.set_new_value("VK_LAYER_LUNARG_*");
3946
3947 InstWrapper inst3{env.vulkan_functions};
3948 inst3.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
3949 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log);
3950 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
3951
3952 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3953 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3954 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3955 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3956 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3957 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3958 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3959 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3960 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3961 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3962 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3963 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3964
3965 // Match suffix
3966 // ------------------------------------------
3967 env.debug_log.clear();
3968 layers_disable_env_var.set_new_value("*Second_layer");
3969
3970 InstWrapper inst4{env.vulkan_functions};
3971 inst4.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
3972 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log);
3973 ASSERT_NO_FATAL_FAILURE(inst4.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
3974
3975 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3976 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
3977 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
3978 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
3979 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
3980 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
3981 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
3982 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
3983 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
3984 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
3985 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
3986 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
3987
3988 // Match substring
3989 // ------------------------------------------
3990 env.debug_log.clear();
3991 layers_disable_env_var.set_new_value("*Second*");
3992
3993 InstWrapper inst5{env.vulkan_functions};
3994 inst5.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
3995 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log);
3996 ASSERT_NO_FATAL_FAILURE(inst5.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
3997
3998 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
3999 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4000 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4001 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4002 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4003 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4004 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4005 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4006 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4007 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4008 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4009 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4010
4011 // Match all with star '*'
4012 // ------------------------------------------
4013 env.debug_log.clear();
4014 layers_disable_env_var.set_new_value("*");
4015
4016 InstWrapper inst6{env.vulkan_functions};
4017 inst6.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4018 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log);
4019 ASSERT_NO_FATAL_FAILURE(inst6.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
4020
4021 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4022 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4023 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4024 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4025 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4026 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4027 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4028 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4029 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4030 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4031 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4032 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4033
4034 // Match all with special name
4035 // ------------------------------------------
4036 env.debug_log.clear();
4037 layers_disable_env_var.set_new_value("~all~");
4038
4039 InstWrapper inst7{env.vulkan_functions};
4040 inst7.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4041 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log);
4042 ASSERT_NO_FATAL_FAILURE(inst7.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
4043
4044 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4045 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4046 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4047 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4048 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4049 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4050 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4051 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4052 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4053 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4054 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4055 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4056
4057 // Match explicit special name
4058 // ------------------------------------------
4059 env.debug_log.clear();
4060 layers_disable_env_var.set_new_value("~explicit~");
4061
4062 InstWrapper inst8{env.vulkan_functions};
4063 inst8.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4064 FillDebugUtilsCreateDetails(inst8.create_info, env.debug_log);
4065 ASSERT_NO_FATAL_FAILURE(inst8.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
4066
4067 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4068 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4069 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4070 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4071 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4072 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4073 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4074 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4075 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4076 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4077 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4078 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4079
4080 // No match implicit special name
4081 // ------------------------------------------
4082 env.debug_log.clear();
4083 layers_disable_env_var.set_new_value("~implicit~");
4084
4085 InstWrapper inst9{env.vulkan_functions};
4086 inst9.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4087 FillDebugUtilsCreateDetails(inst9.create_info, env.debug_log);
4088 ASSERT_NO_FATAL_FAILURE(inst9.CheckCreate());
4089
4090 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4091 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4092 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4093 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4094 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4095 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4096 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4097 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4098 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4099 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4100 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4101 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4102 }
4103
4104 // Verify that VK_LOADER_LAYERS_ENABLE + VK_LOADER_LAYERS_DISABLE work.(results in the layer still being
4105 // enabled)
TEST(TestLayers,EnvironLayerEnableDisableExplicitLayer)4106 TEST(TestLayers, EnvironLayerEnableDisableExplicitLayer) {
4107 FrameworkEnvironment env;
4108 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4109 .set_icd_api_version(VK_API_VERSION_1_2);
4110
4111 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4112 const char* explicit_json_name_1 = "First_layer.json";
4113 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4114 .set_name(explicit_layer_name_1)
4115 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4116 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4117 explicit_json_name_1);
4118
4119 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer";
4120 const char* explicit_json_name_2 = "Second_layer.json";
4121 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4122 .set_name(explicit_layer_name_2)
4123 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4124 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4125 explicit_json_name_2);
4126
4127 const char* explicit_layer_name_3 = "VK_LAYER_LUNARG_Second_test_layer";
4128 const char* explicit_json_name_3 = "Second_test_layer.json";
4129 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4130 .set_name(explicit_layer_name_3)
4131 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4132 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4133 explicit_json_name_3);
4134
4135 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE"};
4136 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"};
4137
4138 // First, test an instance/device without the layer forced on.
4139 InstWrapper inst1{env.vulkan_functions};
4140 inst1.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4141 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log);
4142 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate());
4143
4144 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4145 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4146 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4147 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4148 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4149 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4150 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4151 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4152 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4153 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4154 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4155 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4156
4157 // Disable 2 but enable 1
4158 // ------------------------------------------
4159 env.debug_log.clear();
4160 layers_disable_env_var.set_new_value("*Second*");
4161 layers_enable_env_var.set_new_value("*test_layer");
4162
4163 InstWrapper inst2{env.vulkan_functions};
4164 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log);
4165 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate());
4166
4167 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4168 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4169 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4170 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4171 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4172 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4173 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4174 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4175 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4176 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4177 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4178 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4179
4180 // Disable all but enable 2
4181 // ------------------------------------------
4182 env.debug_log.clear();
4183 layers_disable_env_var.set_new_value("*");
4184 layers_enable_env_var.set_new_value("*Second*");
4185
4186 InstWrapper inst3{env.vulkan_functions};
4187 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log);
4188 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate());
4189
4190 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4191 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4192 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4193 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4194 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4195 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4196 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4197 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4198 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4199 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4200 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4201 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4202
4203 // Disable all but enable 2
4204 // ------------------------------------------
4205 env.debug_log.clear();
4206 layers_disable_env_var.set_new_value("~all~");
4207 layers_enable_env_var.set_new_value("*Second*");
4208
4209 InstWrapper inst4{env.vulkan_functions};
4210 FillDebugUtilsCreateDetails(inst4.create_info, env.debug_log);
4211 ASSERT_NO_FATAL_FAILURE(inst4.CheckCreate());
4212
4213 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4214 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4215 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4216 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4217 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4218 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4219 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4220 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4221 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4222 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4223 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4224 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4225
4226 // Disable explicit but enable 2
4227 // ------------------------------------------
4228 env.debug_log.clear();
4229 layers_disable_env_var.set_new_value("~explicit~");
4230 layers_enable_env_var.set_new_value("*Second*");
4231
4232 InstWrapper inst5{env.vulkan_functions};
4233 FillDebugUtilsCreateDetails(inst5.create_info, env.debug_log);
4234 ASSERT_NO_FATAL_FAILURE(inst5.CheckCreate());
4235
4236 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4237 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4238 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4239 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4240 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4241 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4242 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4243 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4244 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4245 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4246 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4247 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4248
4249 // Disable implicit but enable 2 (should still be everything)
4250 // ------------------------------------------
4251 env.debug_log.clear();
4252 layers_disable_env_var.set_new_value("~implicit~");
4253 layers_enable_env_var.set_new_value("*Second*");
4254
4255 InstWrapper inst6{env.vulkan_functions};
4256 inst6.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4257 FillDebugUtilsCreateDetails(inst6.create_info, env.debug_log);
4258 ASSERT_NO_FATAL_FAILURE(inst6.CheckCreate());
4259
4260 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4261 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4262 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4263 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4264 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4265 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4266 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4267 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4268 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4269 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4270 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4271 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4272
4273 // Disable explicit but enable all
4274 // ------------------------------------------
4275 env.debug_log.clear();
4276 layers_disable_env_var.set_new_value("~explicit~");
4277 layers_enable_env_var.set_new_value("*");
4278
4279 InstWrapper inst7{env.vulkan_functions};
4280 inst7.create_info.add_layer(explicit_layer_name_1).add_layer(explicit_layer_name_2).add_layer(explicit_layer_name_3);
4281 FillDebugUtilsCreateDetails(inst7.create_info, env.debug_log);
4282 ASSERT_NO_FATAL_FAILURE(inst7.CheckCreate());
4283
4284 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4285 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4286 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4287 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4288 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4289 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4290 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4291 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4292 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_3));
4293 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_3));
4294 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "forced enabled due to env var"));
4295 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_3, "disabled because name matches filter of env var"));
4296 }
4297
4298 // Verify that VK_INSTANCE_LAYERS + VK_LOADER_LAYERS_DISABLE work.(results in the layer still being
4299 // enabled)
TEST(TestLayers,EnvironVkInstanceLayersAndDisableFilters)4300 TEST(TestLayers, EnvironVkInstanceLayersAndDisableFilters) {
4301 FrameworkEnvironment env;
4302 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4303 .set_icd_api_version(VK_API_VERSION_1_2);
4304
4305 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4306 const char* explicit_json_name_1 = "First_layer.json";
4307 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4308 .set_name(explicit_layer_name_1)
4309 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4310 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4311 explicit_json_name_1);
4312
4313 const char* explicit_layer_name_2 = "VK_LAYER_LUNARG_Second_layer";
4314 const char* explicit_json_name_2 = "Second_layer.json";
4315 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4316 .set_name(explicit_layer_name_2)
4317 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4318 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4319 explicit_json_name_2);
4320
4321 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS"};
4322 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE"};
4323
4324 // First, test an instance/device without the layer forced on.
4325 InstWrapper inst1{env.vulkan_functions};
4326 inst1.create_info.add_layer(explicit_layer_name_1);
4327 FillDebugUtilsCreateDetails(inst1.create_info, env.debug_log);
4328 ASSERT_NO_FATAL_FAILURE(inst1.CheckCreate());
4329
4330 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4331 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4332 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4333 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4334 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4335 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4336 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4337 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4338
4339 // Enable the non-default enabled layer with VK_INSTANCE_LAYERS
4340 // ------------------------------------------
4341 env.debug_log.clear();
4342 layers_enable_env_var.set_new_value(explicit_layer_name_2);
4343
4344 InstWrapper inst2{env.vulkan_functions};
4345 inst2.create_info.add_layer(explicit_layer_name_1);
4346 FillDebugUtilsCreateDetails(inst2.create_info, env.debug_log);
4347 ASSERT_NO_FATAL_FAILURE(inst2.CheckCreate());
4348
4349 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4350 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4351 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4352 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4353 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4354 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4355 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4356 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4357
4358 // Try to disable all
4359 // ------------------------------------------
4360 env.debug_log.clear();
4361 layers_disable_env_var.set_new_value("*");
4362
4363 InstWrapper inst3{env.vulkan_functions};
4364 inst3.create_info.add_layer(explicit_layer_name_1);
4365 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log);
4366 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
4367
4368 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4369 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_1));
4370 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4371 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4372 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_2));
4373 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer", explicit_layer_name_2));
4374 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "forced enabled due to env var"));
4375 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_2, "disabled because name matches filter of env var"));
4376 }
4377
4378 // Verify that layers enabled through VK_INSTANCE_LAYERS which were not found get the proper error message
TEST(TestLayers,NonExistantLayerInVK_INSTANCE_LAYERS)4379 TEST(TestLayers, NonExistantLayerInVK_INSTANCE_LAYERS) {
4380 FrameworkEnvironment env;
4381 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
4382
4383 const char* layer_name = "VK_LAYER_test_layer";
4384 env.add_explicit_layer(
4385 ManifestLayer{}.add_layer(
4386 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
4387 "test_layer.json");
4388
4389 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS", "VK_LAYER_I_dont_exist"};
4390 {
4391 InstWrapper inst{env.vulkan_functions};
4392 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4393 inst.CheckCreate();
4394
4395 ASSERT_TRUE(
4396 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!"));
4397 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
4398 }
4399 // Make sure layers that do exist are loaded
4400 env.debug_log.clear();
4401 layers_enable_env_var.add_to_list(layer_name);
4402 {
4403 InstWrapper inst{env.vulkan_functions};
4404 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4405 inst.CheckCreate();
4406 ASSERT_TRUE(
4407 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!"));
4408 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
4409 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name));
4410 }
4411 // Make sure that if the layer appears twice in the env-var nothing bad happens
4412 env.debug_log.clear();
4413 layers_enable_env_var.add_to_list("VK_LAYER_I_dont_exist");
4414 {
4415 InstWrapper inst{env.vulkan_functions};
4416 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4417 inst.CheckCreate();
4418 ASSERT_TRUE(
4419 env.debug_log.find("Layer \"VK_LAYER_I_dont_exist\" was not found but was requested by env var VK_INSTANCE_LAYERS!"));
4420 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
4421 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name));
4422 }
4423 }
4424
4425 // Verify that if the same layer appears twice in VK_INSTANCE_LAYERS nothing bad happens
TEST(TestLayers,DuplicatesInEnvironVK_INSTANCE_LAYERS)4426 TEST(TestLayers, DuplicatesInEnvironVK_INSTANCE_LAYERS) {
4427 FrameworkEnvironment env;
4428 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({});
4429
4430 const char* layer_name = "VK_LAYER_test_layer";
4431 env.add_explicit_layer(
4432 ManifestLayer{}.add_layer(
4433 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
4434 "test_layer.json");
4435
4436 EnvVarWrapper layers_enable_env_var{"VK_INSTANCE_LAYERS"};
4437
4438 layers_enable_env_var.add_to_list(layer_name);
4439 layers_enable_env_var.add_to_list(layer_name);
4440
4441 InstWrapper inst{env.vulkan_functions};
4442 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4443 inst.CheckCreate();
4444 auto layer_props = inst.GetActiveLayers(inst.GetPhysDev(), 1);
4445 ASSERT_TRUE(string_eq(layer_props.at(0).layerName, layer_name));
4446 }
4447
TEST(TestLayers,AppEnabledExplicitLayerFails)4448 TEST(TestLayers, AppEnabledExplicitLayerFails) {
4449 FrameworkEnvironment env;
4450 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4451 .set_icd_api_version(VK_API_VERSION_1_2);
4452
4453 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4454 const char* explicit_json_name_1 = "First_layer.json";
4455 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4456 .set_name(explicit_layer_name_1)
4457 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4458 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
4459 explicit_json_name_1);
4460
4461 env.debug_log.clear();
4462 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", explicit_layer_name_1};
4463
4464 ASSERT_NO_FATAL_FAILURE(env.GetLayerProperties(0));
4465
4466 InstWrapper inst3{env.vulkan_functions};
4467 inst3.create_info.add_layer(explicit_layer_name_1);
4468 FillDebugUtilsCreateDetails(inst3.create_info, env.debug_log);
4469 ASSERT_NO_FATAL_FAILURE(inst3.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT));
4470
4471 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4472 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4473 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4474 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4475 }
4476
TEST(TestLayers,OverrideEnabledExplicitLayerWithDisableFilter)4477 TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilter) {
4478 FrameworkEnvironment env;
4479 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4480 .set_icd_api_version(VK_API_VERSION_1_2);
4481
4482 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4483 const char* explicit_json_name_1 = "First_layer.json";
4484 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4485 .set_name(explicit_layer_name_1)
4486 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4487 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
4488 explicit_json_name_1);
4489 env.add_implicit_layer(
4490 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
4491 .set_name(lunarg_meta_layer_name)
4492 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
4493 .add_component_layer(explicit_layer_name_1)
4494 .set_disable_environment("DisableMeIfYouCan")),
4495 "meta_test_layer.json");
4496
4497 env.debug_log.clear();
4498 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", explicit_layer_name_1};
4499
4500 auto layers = env.GetLayerProperties(1);
4501 EXPECT_TRUE(string_eq(lunarg_meta_layer_name, layers[0].layerName));
4502
4503 { // both override layer and Disable env var
4504 InstWrapper inst{env.vulkan_functions};
4505 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4506 inst.CheckCreate();
4507 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4508 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4509 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4510 ASSERT_TRUE(
4511 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4512 }
4513 env.debug_log.clear();
4514 { // Now try to enable the explicit layer as well
4515 InstWrapper inst{env.vulkan_functions};
4516 inst.create_info.add_layer(explicit_layer_name_1);
4517 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4518 inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
4519 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4520 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4521 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4522 ASSERT_TRUE(
4523 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4524 }
4525 }
4526
TEST(TestLayers,OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer)4527 TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer) {
4528 FrameworkEnvironment env;
4529 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4530 .set_icd_api_version(VK_API_VERSION_1_2);
4531
4532 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4533 const char* explicit_json_name_1 = "First_layer.json";
4534 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4535 .set_name(explicit_layer_name_1)
4536 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4537 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
4538 explicit_json_name_1);
4539 env.add_implicit_layer(
4540 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
4541 .set_name(lunarg_meta_layer_name)
4542 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
4543 .add_component_layer(explicit_layer_name_1)
4544 .set_disable_environment("DisableMeIfYouCan")),
4545 "meta_test_layer.json");
4546
4547 env.debug_log.clear();
4548 EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", lunarg_meta_layer_name};
4549
4550 auto layers = env.GetLayerProperties(1);
4551 EXPECT_TRUE(string_eq(explicit_layer_name_1, layers[0].layerName));
4552
4553 { // both override layer and Disable env var
4554 InstWrapper inst{env.vulkan_functions};
4555 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4556 inst.CheckCreate();
4557 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4558 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4559 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4560 ASSERT_TRUE(
4561 env.debug_log.find_prefix_then_postfix(lunarg_meta_layer_name, "disabled because name matches filter of env var"));
4562 }
4563 env.debug_log.clear();
4564 { // Now try to enable the explicit layer as well
4565 InstWrapper inst{env.vulkan_functions};
4566 inst.create_info.add_layer(explicit_layer_name_1);
4567 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4568 inst.CheckCreate();
4569 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4570 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4571 ASSERT_FALSE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4572 ASSERT_TRUE(
4573 env.debug_log.find_prefix_then_postfix(lunarg_meta_layer_name, "disabled because name matches filter of env var"));
4574 }
4575 }
4576
TEST(TestLayers,OverrideBlacklistedLayerWithEnableFilter)4577 TEST(TestLayers, OverrideBlacklistedLayerWithEnableFilter) {
4578 FrameworkEnvironment env;
4579 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4580 .set_icd_api_version(VK_API_VERSION_1_2);
4581
4582 const char* explicit_layer_name_1 = "VK_LAYER_LUNARG_First_layer";
4583 const char* explicit_json_name_1 = "First_layer.json";
4584 env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4585 .set_name(explicit_layer_name_1)
4586 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4587 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
4588 explicit_json_name_1);
4589 env.add_implicit_layer(
4590 ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
4591 .set_name(lunarg_meta_layer_name)
4592 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
4593 .add_blacklisted_layer(explicit_layer_name_1)
4594 .set_disable_environment("DisableMeIfYouCan")),
4595 "meta_test_layer.json");
4596
4597 env.debug_log.clear();
4598 EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", explicit_layer_name_1};
4599
4600 auto layers = env.GetLayerProperties(1);
4601 EXPECT_TRUE(string_eq(explicit_layer_name_1, layers[0].layerName));
4602 {
4603 InstWrapper inst{env.vulkan_functions};
4604 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4605 ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
4606 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4607 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4608 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4609 ASSERT_FALSE(
4610 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4611 }
4612 env.debug_log.clear();
4613 { // Try to enable a blacklisted layer
4614 InstWrapper inst{env.vulkan_functions};
4615 inst.create_info.add_layer(explicit_layer_name_1);
4616 FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
4617 ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
4618 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Insert instance layer ", explicit_layer_name_1));
4619 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix("Found manifest file", explicit_json_name_1));
4620 ASSERT_TRUE(env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "forced enabled due to env var"));
4621 ASSERT_FALSE(
4622 env.debug_log.find_prefix_then_postfix(explicit_layer_name_1, "disabled because name matches filter of env var"));
4623 }
4624 }
4625
4626 // Add a device layer, should not work
TEST(TestLayers,DoNotUseDeviceLayer)4627 TEST(TestLayers, DoNotUseDeviceLayer) {
4628 FrameworkEnvironment env;
4629 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4630 .set_icd_api_version(VK_API_VERSION_1_2)
4631 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
4632
4633 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
4634 env.add_explicit_layer(
4635 ManifestLayer{}.add_layer(
4636 ManifestLayer::LayerDescription{}
4637 .set_name(explicit_layer_name)
4638 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
4639 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
4640 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})
4641 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})),
4642 "explicit_wrap_layer_both_dev.json");
4643
4644 // First, test an instance/device without the layer forced on. The extensions shouldn't be present and
4645 // the function pointers should be NULL.
4646 InstWrapper inst1{env.vulkan_functions};
4647 inst1.CheckCreate();
4648 VkPhysicalDevice phys_dev1 = inst1.GetPhysDev();
4649
4650 // Make sure the extensions in the layer aren't present
4651 ASSERT_NO_FATAL_FAILURE(inst1.EnumerateDeviceExtensions(phys_dev1, 0));
4652
4653 // Create a device and query the function pointers
4654 DeviceWrapper dev1{inst1};
4655 dev1.CheckCreate(phys_dev1);
4656 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolBefore = dev1.load("vkTrimCommandPoolKHR");
4657 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusBefore = dev1.load("vkGetSwapchainStatusKHR");
4658 handle_assert_null(pfn_TrimCommandPoolBefore);
4659 handle_assert_null(pfn_GetSwapchainStatusBefore);
4660
4661 // Now, test an instance/device with the layer forced on. The extensions should be present and
4662 // the function pointers should be valid.
4663 InstWrapper inst2{env.vulkan_functions};
4664 inst2.CheckCreate();
4665 VkPhysicalDevice phys_dev2 = inst2.GetPhysDev();
4666
4667 // Make sure the extensions in the layer aren't present
4668 ASSERT_NO_FATAL_FAILURE(inst2.EnumerateDeviceExtensions(phys_dev2, 0));
4669
4670 DeviceWrapper dev2{inst2};
4671 dev2.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)
4672 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)
4673 .add_layer(explicit_layer_name);
4674 dev2.CheckCreate(phys_dev2, VK_ERROR_EXTENSION_NOT_PRESENT);
4675
4676 DeviceWrapper dev3{inst2};
4677 dev3.create_info.add_layer(explicit_layer_name);
4678 dev3.CheckCreate(phys_dev2);
4679
4680 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev3.load("vkTrimCommandPoolKHR");
4681 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev3.load("vkGetSwapchainStatusKHR");
4682 handle_assert_null(pfn_TrimCommandPoolAfter);
4683 handle_assert_null(pfn_GetSwapchainStatusAfter);
4684 }
4685
4686 // Make sure that a layer enabled as both an instance and device layer works properly.
TEST(TestLayers,InstanceAndDeviceLayer)4687 TEST(TestLayers, InstanceAndDeviceLayer) {
4688 FrameworkEnvironment env;
4689 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4690 .set_icd_api_version(VK_API_VERSION_1_2)
4691 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
4692
4693 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
4694 env.add_explicit_layer(
4695 ManifestLayer{}.add_layer(
4696 ManifestLayer::LayerDescription{}
4697 .set_name(explicit_layer_name)
4698 .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
4699 .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))
4700 .add_device_extension({VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1, {"vkTrimCommandPoolKHR"}})
4701 .add_device_extension({VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, 1, {"vkGetSwapchainStatusKHR"}})),
4702 "explicit_wrap_layer_both_dev.json");
4703
4704 InstWrapper inst{env.vulkan_functions};
4705 inst.create_info.add_layer(explicit_layer_name);
4706 inst.CheckCreate();
4707 VkPhysicalDevice phys_dev = inst.GetPhysDev();
4708
4709 DeviceWrapper dev{inst};
4710 dev.create_info.add_extension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)
4711 .add_extension(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME)
4712 .add_layer(explicit_layer_name);
4713 dev.CheckCreate(phys_dev);
4714
4715 PFN_vkTrimCommandPoolKHR pfn_TrimCommandPoolAfter = dev.load("vkTrimCommandPoolKHR");
4716 PFN_vkGetSwapchainStatusKHR pfn_GetSwapchainStatusAfter = dev.load("vkGetSwapchainStatusKHR");
4717 handle_assert_has_value(pfn_TrimCommandPoolAfter);
4718 handle_assert_has_value(pfn_GetSwapchainStatusAfter);
4719
4720 ASSERT_EQ(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, pfn_GetSwapchainStatusAfter(dev.dev, VK_NULL_HANDLE));
4721 }
4722
4723 // Make sure loader does not throw an error for a device layer that is not present
TEST(TestLayers,DeviceLayerNotPresent)4724 TEST(TestLayers, DeviceLayerNotPresent) {
4725 FrameworkEnvironment env;
4726 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_2))
4727 .set_icd_api_version(VK_API_VERSION_1_2)
4728 .add_physical_device(PhysicalDevice{}.set_api_version(VK_API_VERSION_1_2).finish());
4729 const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
4730
4731 InstWrapper inst{env.vulkan_functions};
4732 inst.CheckCreate();
4733 VkPhysicalDevice phys_dev = inst.GetPhysDev();
4734
4735 DeviceWrapper dev{inst};
4736 dev.create_info.add_layer(explicit_layer_name);
4737 dev.CheckCreate(phys_dev);
4738 }
4739
TEST(LayerPhysDeviceMod,AddPhysicalDevices)4740 TEST(LayerPhysDeviceMod, AddPhysicalDevices) {
4741 FrameworkEnvironment env;
4742 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4743 .set_name("VK_LAYER_LunarG_add_phys_dev")
4744 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4745 .set_api_version(VK_API_VERSION_1_1)
4746 .set_disable_environment("TEST_DISABLE_ADD_PHYS_DEV")),
4747 "test_layer_add.json");
4748
4749 auto& layer = env.get_test_layer(0);
4750 layer.set_add_phys_devs(true);
4751
4752 for (uint32_t icd = 0; icd < 2; ++icd) {
4753 auto& cur_icd =
4754 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
4755 VkPhysicalDeviceProperties properties{};
4756 properties.apiVersion = VK_API_VERSION_1_2;
4757 properties.vendorID = 0x11000000 + (icd << 6);
4758 for (uint32_t dev = 0; dev < 3; ++dev) {
4759 properties.deviceID = properties.vendorID + dev;
4760 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
4761 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
4762 #if defined(_WIN32)
4763 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
4764 #else
4765 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
4766 #endif
4767 cur_icd.add_physical_device({});
4768 cur_icd.physical_devices.back().set_properties(properties);
4769 }
4770 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
4771 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
4772 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
4773 }
4774 const uint32_t icd_devices = 6;
4775
4776 InstWrapper inst{env.vulkan_functions};
4777 inst.create_info.set_api_version(VK_API_VERSION_1_1);
4778 inst.CheckCreate();
4779
4780 uint32_t dev_count = 0;
4781 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr));
4782 ASSERT_GT(dev_count, icd_devices);
4783
4784 auto not_exp_physical_devices = std::vector<VkPhysicalDevice>(icd_devices);
4785 uint32_t returned_phys_dev_count = icd_devices;
4786 ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, not_exp_physical_devices.data()));
4787 ASSERT_EQ(icd_devices, returned_phys_dev_count);
4788
4789 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count);
4790 returned_phys_dev_count = dev_count;
4791 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data()));
4792 ASSERT_EQ(dev_count, returned_phys_dev_count);
4793
4794 uint32_t diff_count = dev_count - icd_devices;
4795 uint32_t found_incomplete = 0;
4796 uint32_t found_added_count = 0;
4797 for (uint32_t dev = 0; dev < dev_count; ++dev) {
4798 VkPhysicalDeviceProperties props{};
4799 inst->vkGetPhysicalDeviceProperties(physical_devices[dev], &props);
4800 if (string_eq(props.deviceName, "physdev_added_xx")) {
4801 found_added_count++;
4802 }
4803 for (uint32_t incomp = 0; incomp < icd_devices; ++incomp) {
4804 if (not_exp_physical_devices[incomp] == physical_devices[dev]) {
4805 found_incomplete++;
4806 break;
4807 }
4808 }
4809 }
4810
4811 // We should have added the number of diff items, and the incomplete count should match the number of
4812 // original physical devices.
4813 ASSERT_EQ(found_added_count, diff_count);
4814 ASSERT_EQ(found_incomplete, icd_devices);
4815 }
4816
TEST(LayerPhysDeviceMod,RemovePhysicalDevices)4817 TEST(LayerPhysDeviceMod, RemovePhysicalDevices) {
4818 FrameworkEnvironment env;
4819 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4820 .set_name("VK_LAYER_LunarG_remove_phys_dev")
4821 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4822 .set_api_version(VK_API_VERSION_1_1)
4823 .set_disable_environment("TEST_DISABLE_REMOVE_PHYS_DEV")),
4824 "test_layer_remove.json");
4825
4826 auto& layer = env.get_test_layer(0);
4827 layer.set_remove_phys_devs(true);
4828
4829 for (uint32_t icd = 0; icd < 2; ++icd) {
4830 auto& cur_icd =
4831 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
4832 VkPhysicalDeviceProperties properties{};
4833 properties.apiVersion = VK_API_VERSION_1_2;
4834 properties.vendorID = 0x11000000 + (icd << 6);
4835 for (uint32_t dev = 0; dev < 3; ++dev) {
4836 properties.deviceID = properties.vendorID + dev;
4837 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
4838 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
4839 #if defined(_WIN32)
4840 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
4841 #else
4842 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
4843 #endif
4844 cur_icd.add_physical_device({});
4845 cur_icd.physical_devices.back().set_properties(properties);
4846 }
4847 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
4848 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
4849 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
4850 }
4851 const uint32_t icd_devices = 6;
4852
4853 InstWrapper inst{env.vulkan_functions};
4854 inst.create_info.set_api_version(VK_API_VERSION_1_1);
4855 inst.CheckCreate();
4856
4857 uint32_t dev_count = 0;
4858 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr));
4859 ASSERT_LT(dev_count, icd_devices);
4860
4861 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count);
4862 uint32_t returned_phys_dev_count = dev_count;
4863 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data()));
4864 ASSERT_EQ(dev_count, returned_phys_dev_count);
4865 }
4866
TEST(LayerPhysDeviceMod,ReorderPhysicalDevices)4867 TEST(LayerPhysDeviceMod, ReorderPhysicalDevices) {
4868 FrameworkEnvironment env;
4869 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4870 .set_name("VK_LAYER_LunarG_reorder_phys_dev")
4871 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4872 .set_api_version(VK_API_VERSION_1_1)
4873 .set_disable_environment("TEST_DISABLE_REORDER_PHYS_DEV")),
4874 "test_layer_reorder.json");
4875
4876 auto& layer = env.get_test_layer(0);
4877 layer.set_reorder_phys_devs(true);
4878
4879 for (uint32_t icd = 0; icd < 2; ++icd) {
4880 auto& cur_icd =
4881 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
4882 VkPhysicalDeviceProperties properties{};
4883 properties.apiVersion = VK_API_VERSION_1_2;
4884 properties.vendorID = 0x11000000 + (icd << 6);
4885 for (uint32_t dev = 0; dev < 3; ++dev) {
4886 properties.deviceID = properties.vendorID + dev;
4887 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
4888 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
4889 #if defined(_WIN32)
4890 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
4891 #else
4892 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
4893 #endif
4894 cur_icd.add_physical_device({});
4895 cur_icd.physical_devices.back().set_properties(properties);
4896 }
4897 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
4898 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
4899 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
4900 }
4901 const uint32_t icd_devices = 6;
4902
4903 InstWrapper inst{env.vulkan_functions};
4904 inst.create_info.set_api_version(VK_API_VERSION_1_1);
4905 inst.CheckCreate();
4906
4907 uint32_t dev_count = 0;
4908 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr));
4909 ASSERT_EQ(dev_count, icd_devices);
4910
4911 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count);
4912 uint32_t returned_phys_dev_count = dev_count;
4913 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data()));
4914 ASSERT_EQ(dev_count, returned_phys_dev_count);
4915 }
4916
TEST(LayerPhysDeviceMod,AddRemoveAndReorderPhysicalDevices)4917 TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
4918 FrameworkEnvironment env;
4919 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4920 .set_name("VK_LAYER_LunarG_all_phys_dev")
4921 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4922 .set_api_version(VK_API_VERSION_1_1)
4923 .set_disable_environment("TEST_DISABLE_ALL_PHYS_DEV")),
4924 "test_layer_all.json");
4925
4926 auto& layer = env.get_test_layer(0);
4927 layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true);
4928
4929 for (uint32_t icd = 0; icd < 2; ++icd) {
4930 auto& cur_icd =
4931 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
4932 VkPhysicalDeviceProperties properties{};
4933 properties.apiVersion = VK_API_VERSION_1_2;
4934 properties.vendorID = 0x11000000 + (icd << 6);
4935 for (uint32_t dev = 0; dev < 3; ++dev) {
4936 properties.deviceID = properties.vendorID + dev;
4937 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
4938 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
4939 #if defined(_WIN32)
4940 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
4941 #else
4942 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
4943 #endif
4944 cur_icd.add_physical_device({});
4945 cur_icd.physical_devices.back().set_properties(properties);
4946 }
4947 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
4948 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
4949 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
4950 }
4951 const uint32_t icd_devices = 6;
4952
4953 InstWrapper inst{env.vulkan_functions};
4954 inst.create_info.set_api_version(VK_API_VERSION_1_1);
4955 inst.CheckCreate();
4956
4957 uint32_t dev_count = 0;
4958 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &dev_count, nullptr));
4959 ASSERT_GT(dev_count, icd_devices);
4960
4961 auto physical_devices = std::vector<VkPhysicalDevice>(dev_count);
4962 uint32_t returned_phys_dev_count = dev_count;
4963 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_phys_dev_count, physical_devices.data()));
4964 ASSERT_EQ(dev_count, returned_phys_dev_count);
4965
4966 uint32_t found_added_count = 0;
4967 for (uint32_t dev = 0; dev < dev_count; ++dev) {
4968 VkPhysicalDeviceProperties props{};
4969 inst->vkGetPhysicalDeviceProperties(physical_devices[dev], &props);
4970 if (string_eq(props.deviceName, "physdev_added_xx")) {
4971 found_added_count++;
4972 }
4973 }
4974
4975 // Should see 2 removed, but 3 added so a diff count of 1
4976 uint32_t diff_count = dev_count - icd_devices;
4977 ASSERT_EQ(1U, diff_count);
4978 ASSERT_EQ(found_added_count, 3U);
4979 }
4980
GroupsAreTheSame(VkPhysicalDeviceGroupProperties a,VkPhysicalDeviceGroupProperties b)4981 bool GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDeviceGroupProperties b) {
4982 if (a.physicalDeviceCount != b.physicalDeviceCount) {
4983 return false;
4984 }
4985 for (uint32_t dev = 0; dev < a.physicalDeviceCount; ++dev) {
4986 if (a.physicalDevices[dev] != b.physicalDevices[dev]) {
4987 return false;
4988 }
4989 }
4990 return true;
4991 }
4992
TEST(LayerPhysDeviceMod,AddPhysicalDeviceGroups)4993 TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
4994 FrameworkEnvironment env;
4995 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
4996 .set_name("VK_LAYER_LunarG_add_phys_dev")
4997 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
4998 .set_api_version(VK_API_VERSION_1_1)
4999 .set_disable_environment("TEST_DISABLE_ADD_PHYS_DEV")),
5000 "test_layer_remove.json");
5001
5002 auto& layer = env.get_test_layer(0);
5003 layer.set_add_phys_devs(true);
5004
5005 for (uint32_t icd = 0; icd < 2; ++icd) {
5006 auto& cur_icd =
5007 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
5008 VkPhysicalDeviceProperties properties{};
5009 properties.apiVersion = VK_API_VERSION_1_2;
5010 properties.vendorID = 0x11000000 + (icd << 6);
5011 for (uint32_t dev = 0; dev < 3; ++dev) {
5012 properties.deviceID = properties.vendorID + dev;
5013 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
5014 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
5015 #if defined(_WIN32)
5016 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
5017 #else
5018 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
5019 #endif
5020 cur_icd.add_physical_device({});
5021 cur_icd.physical_devices.back().set_properties(properties);
5022 }
5023 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
5024 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
5025 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
5026 }
5027 const uint32_t icd_groups = 4;
5028
5029 InstWrapper inst{env.vulkan_functions};
5030 inst.create_info.set_api_version(VK_API_VERSION_1_1);
5031 inst.CheckCreate();
5032
5033 uint32_t grp_count = 0;
5034 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr));
5035 ASSERT_GT(grp_count, icd_groups);
5036
5037 auto not_exp_phys_dev_groups =
5038 std::vector<VkPhysicalDeviceGroupProperties>(icd_groups, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES});
5039
5040 uint32_t returned_group_count = icd_groups;
5041 ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, not_exp_phys_dev_groups.data()));
5042 ASSERT_EQ(icd_groups, returned_group_count);
5043
5044 auto phys_dev_groups =
5045 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES});
5046
5047 returned_group_count = grp_count;
5048 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data()));
5049 ASSERT_EQ(grp_count, returned_group_count);
5050
5051 uint32_t diff_count = grp_count - icd_groups;
5052 uint32_t found_incomplete = 0;
5053 uint32_t found_added_count = 0;
5054 for (uint32_t grp = 0; grp < grp_count; ++grp) {
5055 // Shortcut, only groups with 1 device could be added in the newly added count
5056 if (1 == phys_dev_groups[grp].physicalDeviceCount) {
5057 for (uint32_t dev = 0; dev < phys_dev_groups[grp].physicalDeviceCount; ++dev) {
5058 VkPhysicalDeviceProperties props{};
5059 inst->vkGetPhysicalDeviceProperties(phys_dev_groups[grp].physicalDevices[dev], &props);
5060 if (string_eq(props.deviceName, "physdev_added_xx")) {
5061 found_added_count++;
5062 }
5063 }
5064 }
5065 for (uint32_t incomp = 0; incomp < icd_groups; ++incomp) {
5066 if (GroupsAreTheSame(not_exp_phys_dev_groups[incomp], phys_dev_groups[grp])) {
5067 found_incomplete++;
5068 break;
5069 }
5070 }
5071 }
5072
5073 // We should have added the number of diff items, and the incomplete count should match the number of
5074 // original physical devices.
5075 ASSERT_EQ(found_added_count, diff_count);
5076 ASSERT_EQ(found_incomplete, icd_groups);
5077 }
5078
TEST(LayerPhysDeviceMod,RemovePhysicalDeviceGroups)5079 TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
5080 FrameworkEnvironment env;
5081 EnvVarWrapper disable_linux_sort("VK_LOADER_DISABLE_SELECT", "1");
5082 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5083 .set_name("VK_LAYER_LunarG_remove_phys_dev")
5084 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5085 .set_api_version(VK_API_VERSION_1_1)
5086 .set_disable_environment("TEST_DISABLE_REMOVE_PHYS_DEV")),
5087 "test_layer_remove.json");
5088
5089 auto& layer = env.get_test_layer(0);
5090 layer.set_remove_phys_devs(true);
5091
5092 for (uint32_t icd = 0; icd < 2; ++icd) {
5093 auto& cur_icd =
5094 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
5095 VkPhysicalDeviceProperties properties{};
5096 properties.apiVersion = VK_API_VERSION_1_2;
5097 properties.vendorID = 0x11000000 + (icd << 6);
5098 for (uint32_t dev = 0; dev < 3; ++dev) {
5099 properties.deviceID = properties.vendorID + dev;
5100 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
5101 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
5102 #if defined(_WIN32)
5103 strncpy_s(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
5104 #else
5105 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
5106 #endif
5107 cur_icd.add_physical_device({});
5108 cur_icd.physical_devices.back().set_properties(properties);
5109 }
5110 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
5111 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
5112 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
5113 }
5114 const uint32_t icd_groups = 3;
5115
5116 InstWrapper inst{env.vulkan_functions};
5117 inst.create_info.set_api_version(VK_API_VERSION_1_1);
5118 inst.CheckCreate();
5119
5120 uint32_t grp_count = 0;
5121 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr));
5122 ASSERT_EQ(grp_count, icd_groups);
5123
5124 auto phys_dev_groups =
5125 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES});
5126
5127 uint32_t returned_group_count = grp_count;
5128 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data()));
5129 ASSERT_EQ(grp_count, returned_group_count);
5130 }
5131
TEST(LayerPhysDeviceMod,ReorderPhysicalDeviceGroups)5132 TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
5133 FrameworkEnvironment env;
5134 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5135 .set_name("VK_LAYER_LunarG_reorder_phys_dev")
5136 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5137 .set_api_version(VK_API_VERSION_1_1)
5138 .set_disable_environment("TEST_DISABLE_REORDER_PHYS_DEV")),
5139 "test_layer_reorder.json");
5140
5141 auto& layer = env.get_test_layer(0);
5142 layer.set_reorder_phys_devs(true);
5143
5144 for (uint32_t icd = 0; icd < 2; ++icd) {
5145 auto& cur_icd =
5146 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
5147 VkPhysicalDeviceProperties properties{};
5148 properties.apiVersion = VK_API_VERSION_1_2;
5149 properties.vendorID = 0x11000000 + (icd << 6);
5150 for (uint32_t dev = 0; dev < 3; ++dev) {
5151 properties.deviceID = properties.vendorID + dev;
5152 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
5153 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
5154 #if defined(_WIN32)
5155 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
5156 #else
5157 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
5158 #endif
5159 cur_icd.add_physical_device({});
5160 cur_icd.physical_devices.back().set_properties(properties);
5161 }
5162 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
5163 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[1]);
5164 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[2]);
5165 }
5166 const uint32_t icd_groups = 4;
5167
5168 InstWrapper inst{env.vulkan_functions};
5169 inst.create_info.set_api_version(VK_API_VERSION_1_1);
5170 inst.CheckCreate();
5171
5172 uint32_t grp_count = 0;
5173 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr));
5174 ASSERT_EQ(grp_count, icd_groups);
5175
5176 auto phys_dev_groups =
5177 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES});
5178
5179 uint32_t returned_group_count = grp_count;
5180 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data()));
5181 ASSERT_EQ(grp_count, returned_group_count);
5182 }
5183
TEST(LayerPhysDeviceMod,AddRemoveAndReorderPhysicalDeviceGroups)5184 TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
5185 FrameworkEnvironment env;
5186 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5187 .set_name("VK_LAYER_LunarG_all_phys_dev")
5188 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5189 .set_api_version(VK_API_VERSION_1_1)
5190 .set_disable_environment("TEST_DISABLE_ALL_PHYS_DEV")),
5191 "test_layer_all.json");
5192
5193 auto& layer = env.get_test_layer(0);
5194 layer.set_add_phys_devs(true).set_remove_phys_devs(true).set_reorder_phys_devs(true);
5195
5196 for (uint32_t icd = 0; icd < 2; ++icd) {
5197 auto& cur_icd =
5198 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2, VK_API_VERSION_1_2)).set_icd_api_version(VK_API_VERSION_1_2);
5199 VkPhysicalDeviceProperties properties{};
5200 properties.apiVersion = VK_API_VERSION_1_2;
5201 properties.vendorID = 0x11000000 + (icd << 6);
5202 for (uint32_t dev = 0; dev < 3; ++dev) {
5203 properties.deviceID = properties.vendorID + dev;
5204 properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
5205 auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
5206 #if defined(_WIN32)
5207 strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
5208 #else
5209 strncpy(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
5210 #endif
5211 cur_icd.add_physical_device({});
5212 cur_icd.physical_devices.back().set_properties(properties);
5213 }
5214 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[0]);
5215 cur_icd.physical_device_groups.back().use_physical_device(cur_icd.physical_devices[1]);
5216 cur_icd.physical_device_groups.emplace_back(cur_icd.physical_devices[2]);
5217 }
5218 const uint32_t icd_groups = 4;
5219
5220 InstWrapper inst{env.vulkan_functions};
5221 inst.create_info.set_api_version(VK_API_VERSION_1_1);
5222 inst.CheckCreate();
5223
5224 uint32_t grp_count = 0;
5225 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &grp_count, nullptr));
5226 ASSERT_GT(grp_count, icd_groups);
5227
5228 auto phys_dev_groups =
5229 std::vector<VkPhysicalDeviceGroupProperties>(grp_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES});
5230
5231 uint32_t returned_group_count = grp_count;
5232 ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, phys_dev_groups.data()));
5233 ASSERT_EQ(grp_count, returned_group_count);
5234
5235 uint32_t diff_count = grp_count - icd_groups;
5236 uint32_t found_added_count = 0;
5237 for (uint32_t grp = 0; grp < grp_count; ++grp) {
5238 // Shortcut, only groups with 1 device could be added in the newly added count
5239 if (1 == phys_dev_groups[grp].physicalDeviceCount) {
5240 for (uint32_t dev = 0; dev < phys_dev_groups[grp].physicalDeviceCount; ++dev) {
5241 VkPhysicalDeviceProperties props{};
5242 inst->vkGetPhysicalDeviceProperties(phys_dev_groups[grp].physicalDevices[dev], &props);
5243 if (string_eq(props.deviceName, "physdev_added_xx")) {
5244 found_added_count++;
5245 }
5246 }
5247 }
5248 }
5249
5250 // Should see 2 devices removed which should result in 1 group removed and since 3
5251 // devices were added we should have 3 new groups. So we should have a diff of 2
5252 // groups and 3 new groups
5253 ASSERT_EQ(2U, diff_count);
5254 ASSERT_EQ(found_added_count, 3U);
5255 }
5256
TEST(TestLayers,AllowFilterWithExplicitLayer)5257 TEST(TestLayers, AllowFilterWithExplicitLayer) {
5258 FrameworkEnvironment env;
5259 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
5260 const char* layer_name = "VK_LAYER_test_layer";
5261 env.add_explicit_layer(
5262 ManifestLayer{}.add_layer(
5263 ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
5264 "test_layer_all.json");
5265
5266 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name};
5267 {
5268 InstWrapper inst{env.vulkan_functions};
5269 inst.CheckCreate();
5270
5271 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5272 }
5273 {
5274 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5275
5276 InstWrapper inst{env.vulkan_functions};
5277 inst.CheckCreate();
5278
5279 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5280 }
5281 {
5282 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5283 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5284
5285 InstWrapper inst{env.vulkan_functions};
5286 inst.CheckCreate();
5287
5288 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5289 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5290 }
5291 {
5292 InstWrapper inst{env.vulkan_functions};
5293 inst.create_info.add_layer(layer_name);
5294 inst.CheckCreate();
5295
5296 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5297 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5298 }
5299 {
5300 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5301 LoaderSettingsLayerConfiguration{}
5302 .set_name(layer_name)
5303 .set_control("on")
5304 .set_path(env.get_shimmed_layer_manifest_path(0))
5305 .set_treat_as_implicit_manifest(false)));
5306 env.update_loader_settings(env.loader_settings);
5307
5308 InstWrapper inst{env.vulkan_functions};
5309 inst.CheckCreate();
5310
5311 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5312 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5313 }
5314 {
5315 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5316 env.update_loader_settings(env.loader_settings);
5317
5318 InstWrapper inst{env.vulkan_functions};
5319 inst.CheckCreate();
5320
5321 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5322 }
5323 {
5324 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
5325 env.update_loader_settings(env.loader_settings);
5326
5327 InstWrapper inst{env.vulkan_functions};
5328 inst.CheckCreate();
5329
5330 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5331 }
5332 }
5333
TEST(TestLayers,AllowFilterWithImplicitLayer)5334 TEST(TestLayers, AllowFilterWithImplicitLayer) {
5335 FrameworkEnvironment env;
5336 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
5337 const char* layer_name = "VK_LAYER_test_layer";
5338 const char* disable_env_var = "TEST_DISABLE_ENV_VAR";
5339 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5340 .set_name(layer_name)
5341 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5342 .set_disable_environment(disable_env_var)),
5343 "test_layer_all.json");
5344
5345 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name};
5346
5347 {
5348 InstWrapper inst{env.vulkan_functions};
5349 inst.CheckCreate();
5350
5351 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5352 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5353 }
5354 {
5355 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5356
5357 InstWrapper inst{env.vulkan_functions};
5358 inst.CheckCreate();
5359
5360 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5361 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5362 }
5363 {
5364 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5365 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5366
5367 InstWrapper inst{env.vulkan_functions};
5368 inst.CheckCreate();
5369
5370 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5371 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5372 }
5373 {
5374 InstWrapper inst{env.vulkan_functions};
5375 inst.create_info.add_layer(layer_name);
5376 inst.CheckCreate();
5377
5378 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5379 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5380 }
5381 {
5382 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5383 LoaderSettingsLayerConfiguration{}
5384 .set_name(layer_name)
5385 .set_control("on")
5386 .set_path(env.get_shimmed_layer_manifest_path(0))
5387 .set_treat_as_implicit_manifest(true)));
5388 env.update_loader_settings(env.loader_settings);
5389
5390 InstWrapper inst{env.vulkan_functions};
5391 inst.CheckCreate();
5392
5393 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5394 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5395 }
5396 {
5397 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5398 env.update_loader_settings(env.loader_settings);
5399
5400 InstWrapper inst{env.vulkan_functions};
5401 inst.CheckCreate();
5402
5403 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5404 }
5405 {
5406 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
5407 env.update_loader_settings(env.loader_settings);
5408
5409 InstWrapper inst{env.vulkan_functions};
5410 inst.CheckCreate();
5411
5412 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5413 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5414 }
5415
5416 env.remove_loader_settings();
5417
5418 // Set the disable_environment variable
5419 EnvVarWrapper set_disable_env_var{disable_env_var, "1"};
5420
5421 {
5422 InstWrapper inst{env.vulkan_functions};
5423 inst.CheckCreate();
5424
5425 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5426 }
5427 {
5428 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5429
5430 InstWrapper inst{env.vulkan_functions};
5431 inst.CheckCreate();
5432
5433 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5434 }
5435 {
5436 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5437 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5438
5439 InstWrapper inst{env.vulkan_functions};
5440 inst.CheckCreate();
5441
5442 // layer's disable_environment takes priority
5443 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5444 }
5445 {
5446 InstWrapper inst{env.vulkan_functions};
5447 inst.create_info.add_layer(layer_name);
5448 inst.CheckCreate();
5449
5450 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5451 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5452 }
5453 {
5454 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5455 LoaderSettingsLayerConfiguration{}
5456 .set_name(layer_name)
5457 .set_control("on")
5458 .set_path(env.get_shimmed_layer_manifest_path(0))
5459 .set_treat_as_implicit_manifest(true)));
5460 env.update_loader_settings(env.loader_settings);
5461
5462 InstWrapper inst{env.vulkan_functions};
5463 inst.CheckCreate();
5464
5465 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5466 }
5467 {
5468 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5469 env.update_loader_settings(env.loader_settings);
5470
5471 InstWrapper inst{env.vulkan_functions};
5472 inst.CheckCreate();
5473
5474 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5475 }
5476 {
5477 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
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
TEST(TestLayers,AllowFilterWithConditionallyImlicitLayer)5487 TEST(TestLayers, AllowFilterWithConditionallyImlicitLayer) {
5488 FrameworkEnvironment env;
5489 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
5490 const char* layer_name = "VK_LAYER_test_layer";
5491 const char* enable_env_var = "TEST_ENABLE_ENV_VAR";
5492 env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5493 .set_name(layer_name)
5494 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5495 .set_disable_environment("TEST_DISABLE_ENV_VAR")
5496 .set_enable_environment(enable_env_var)),
5497 "test_layer_all.json");
5498
5499 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name};
5500
5501 {
5502 InstWrapper inst{env.vulkan_functions};
5503 inst.CheckCreate();
5504
5505 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5506 }
5507 {
5508 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5509
5510 InstWrapper inst{env.vulkan_functions};
5511 inst.CheckCreate();
5512
5513 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5514 }
5515 {
5516 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5517 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5518
5519 InstWrapper inst{env.vulkan_functions};
5520 inst.CheckCreate();
5521
5522 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5523 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5524 }
5525 {
5526 InstWrapper inst{env.vulkan_functions};
5527 inst.create_info.add_layer(layer_name);
5528 inst.CheckCreate();
5529
5530 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5531 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5532 }
5533 {
5534 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5535 LoaderSettingsLayerConfiguration{}
5536 .set_name(layer_name)
5537 .set_control("on")
5538 .set_path(env.get_shimmed_layer_manifest_path(0))
5539 .set_treat_as_implicit_manifest(true)));
5540 env.update_loader_settings(env.loader_settings);
5541
5542 InstWrapper inst{env.vulkan_functions};
5543 inst.CheckCreate();
5544
5545 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5546 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5547 }
5548 {
5549 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5550 env.update_loader_settings(env.loader_settings);
5551
5552 InstWrapper inst{env.vulkan_functions};
5553 inst.CheckCreate();
5554
5555 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5556 }
5557 {
5558 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
5559 env.update_loader_settings(env.loader_settings);
5560
5561 InstWrapper inst{env.vulkan_functions};
5562 inst.CheckCreate();
5563
5564 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5565 }
5566
5567 env.remove_loader_settings();
5568
5569 // Repeate the above tests but with the enable_environment variable set
5570 EnvVarWrapper set_enable_env_var{enable_env_var, "1"};
5571
5572 {
5573 InstWrapper inst{env.vulkan_functions};
5574 inst.CheckCreate();
5575
5576 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5577 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5578 }
5579 {
5580 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5581
5582 InstWrapper inst{env.vulkan_functions};
5583 inst.CheckCreate();
5584
5585 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5586 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5587 }
5588 {
5589 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5590 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5591
5592 InstWrapper inst{env.vulkan_functions};
5593 inst.CheckCreate();
5594
5595 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5596 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5597 }
5598 {
5599 InstWrapper inst{env.vulkan_functions};
5600 inst.create_info.add_layer(layer_name);
5601 inst.CheckCreate();
5602
5603 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5604 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5605 }
5606 {
5607 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5608 LoaderSettingsLayerConfiguration{}
5609 .set_name(layer_name)
5610 .set_control("on")
5611 .set_path(env.get_shimmed_layer_manifest_path(0))
5612 .set_treat_as_implicit_manifest(true)));
5613 env.update_loader_settings(env.loader_settings);
5614
5615 InstWrapper inst{env.vulkan_functions};
5616 inst.CheckCreate();
5617
5618 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5619 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5620 }
5621 {
5622 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5623 env.update_loader_settings(env.loader_settings);
5624
5625 InstWrapper inst{env.vulkan_functions};
5626 inst.CheckCreate();
5627
5628 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5629 }
5630 {
5631 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
5632 env.update_loader_settings(env.loader_settings);
5633
5634 InstWrapper inst{env.vulkan_functions};
5635 inst.CheckCreate();
5636
5637 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5638 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5639 }
5640 }
5641
TEST(TestLayers,AllowFilterWithConditionallyImlicitLayerWithOverrideLayer)5642 TEST(TestLayers, AllowFilterWithConditionallyImlicitLayerWithOverrideLayer) {
5643 FrameworkEnvironment env;
5644 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device({});
5645 const char* layer_name = "VK_LAYER_test_layer";
5646 const char* enable_env_var = "TEST_ENABLE_ENV_VAR";
5647 env.add_implicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
5648 .set_name(layer_name)
5649 .set_api_version(VK_API_VERSION_1_1)
5650 .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
5651 .set_disable_environment("TEST_DISABLE_ENV_VAR")
5652 .set_enable_environment(enable_env_var)),
5653 "test_layer_all.json"}
5654 .set_discovery_type(ManifestDiscoveryType::override_folder));
5655
5656 env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
5657 ManifestLayer::LayerDescription{}
5658 .set_name(lunarg_meta_layer_name)
5659 .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
5660 .add_component_layer(layer_name)
5661 .set_disable_environment("DisableMeIfYouCan")
5662 .add_override_path(env.get_folder(ManifestLocation::override_layer).location().string())),
5663 "meta_test_layer.json");
5664
5665 EnvVarWrapper allow{"VK_LOADER_LAYERS_ALLOW", layer_name};
5666
5667 {
5668 InstWrapper inst{env.vulkan_functions};
5669 inst.CheckCreate();
5670
5671 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2);
5672 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5673 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name));
5674 }
5675 {
5676 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5677
5678 InstWrapper inst{env.vulkan_functions};
5679 inst.CheckCreate();
5680
5681 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2);
5682 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5683 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name));
5684 }
5685 {
5686 EnvVarWrapper disable{"VK_LOADER_LAYERS_DISABLE", layer_name};
5687 EnvVarWrapper enable{"VK_LOADER_LAYERS_ENABLE", layer_name};
5688
5689 InstWrapper inst{env.vulkan_functions};
5690 inst.CheckCreate();
5691
5692 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2);
5693 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5694 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name));
5695 }
5696 {
5697 InstWrapper inst{env.vulkan_functions};
5698 inst.create_info.add_layer(layer_name);
5699 inst.CheckCreate();
5700
5701 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 2);
5702 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5703 ASSERT_TRUE(string_eq(layers.at(1).layerName, lunarg_meta_layer_name));
5704 }
5705 {
5706 env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(
5707 LoaderSettingsLayerConfiguration{}
5708 .set_name(layer_name)
5709 .set_control("on")
5710 .set_path(env.get_shimmed_layer_manifest_path(0))
5711 .set_treat_as_implicit_manifest(true)));
5712 env.update_loader_settings(env.loader_settings);
5713
5714 InstWrapper inst{env.vulkan_functions};
5715 inst.CheckCreate();
5716
5717 auto layers = inst.GetActiveLayers(inst.GetPhysDev(), 1);
5718 ASSERT_TRUE(string_eq(layers.at(0).layerName, layer_name));
5719 }
5720 {
5721 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("off");
5722 env.update_loader_settings(env.loader_settings);
5723
5724 InstWrapper inst{env.vulkan_functions};
5725 inst.CheckCreate();
5726
5727 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5728 }
5729 {
5730 env.loader_settings.app_specific_settings.at(0).layer_configurations.at(0).set_control("auto");
5731 env.update_loader_settings(env.loader_settings);
5732
5733 InstWrapper inst{env.vulkan_functions};
5734 inst.CheckCreate();
5735
5736 ASSERT_NO_FATAL_FAILURE(inst.GetActiveLayers(inst.GetPhysDev(), 0));
5737 }
5738 }
5739