Cleanup BUILDER_VALUE macros in tests

Changes BUILDER_VALUE & BUILDER_VECTOR to deduce the return type, so
the class name doesn't need to be given.

Changes BUILDER_VALUE to default everything with {}, and adds
BUILDER_VALUE_WITH_DEFAULT for the places that want a specific default
value instead.

Author: charles-lunarg

tests/framework/icd/test_icd.h

@@ -79,39 +79,39 @@ struct PhysicalDevice {
     PhysicalDevice(const char* name) : deviceName(name) {}
 
     DispatchableHandle<VkPhysicalDevice> vk_physical_device;
-    BUILDER_VALUE(PhysicalDevice, std::string, deviceName, "")
-    BUILDER_VALUE(PhysicalDevice, VkPhysicalDeviceProperties, properties, {})
-    BUILDER_VALUE(PhysicalDevice, VkPhysicalDeviceFeatures, features, {})
-    BUILDER_VALUE(PhysicalDevice, VkPhysicalDeviceMemoryProperties, memory_properties, {})
-    BUILDER_VALUE(PhysicalDevice, VkImageFormatProperties, image_format_properties, {})
-    BUILDER_VALUE(PhysicalDevice, VkExternalMemoryProperties, external_memory_properties, {})
-    BUILDER_VALUE(PhysicalDevice, VkExternalSemaphoreProperties, external_semaphore_properties, {})
-    BUILDER_VALUE(PhysicalDevice, VkExternalFenceProperties, external_fence_properties, {})
-    BUILDER_VALUE(PhysicalDevice, uint32_t, pci_bus, {})
-
-    BUILDER_VECTOR(PhysicalDevice, MockQueueFamilyProperties, queue_family_properties, queue_family_properties)
-    BUILDER_VECTOR(PhysicalDevice, VkFormatProperties, format_properties, format_properties)
-    BUILDER_VECTOR(PhysicalDevice, VkSparseImageFormatProperties, sparse_image_format_properties, sparse_image_format_properties)
-
-    BUILDER_VECTOR(PhysicalDevice, Extension, extensions, extension)
-
-    BUILDER_VALUE(PhysicalDevice, VkSurfaceCapabilitiesKHR, surface_capabilities, {})
-    BUILDER_VECTOR(PhysicalDevice, VkSurfaceFormatKHR, surface_formats, surface_format)
-    BUILDER_VECTOR(PhysicalDevice, VkPresentModeKHR, surface_present_modes, surface_present_mode)
-    BUILDER_VALUE(PhysicalDevice, VkSurfacePresentScalingCapabilitiesEXT, surface_present_scaling_capabilities, {})
+    BUILDER_VALUE(std::string, deviceName)
+    BUILDER_VALUE(VkPhysicalDeviceProperties, properties)
+    BUILDER_VALUE(VkPhysicalDeviceFeatures, features)
+    BUILDER_VALUE(VkPhysicalDeviceMemoryProperties, memory_properties)
+    BUILDER_VALUE(VkImageFormatProperties, image_format_properties)
+    BUILDER_VALUE(VkExternalMemoryProperties, external_memory_properties)
+    BUILDER_VALUE(VkExternalSemaphoreProperties, external_semaphore_properties)
+    BUILDER_VALUE(VkExternalFenceProperties, external_fence_properties)
+    BUILDER_VALUE(uint32_t, pci_bus)
+
+    BUILDER_VECTOR(MockQueueFamilyProperties, queue_family_properties, queue_family_properties)
+    BUILDER_VECTOR(VkFormatProperties, format_properties, format_properties)
+    BUILDER_VECTOR(VkSparseImageFormatProperties, sparse_image_format_properties, sparse_image_format_properties)
+
+    BUILDER_VECTOR(Extension, extensions, extension)
+
+    BUILDER_VALUE(VkSurfaceCapabilitiesKHR, surface_capabilities)
+    BUILDER_VECTOR(VkSurfaceFormatKHR, surface_formats, surface_format)
+    BUILDER_VECTOR(VkPresentModeKHR, surface_present_modes, surface_present_mode)
+    BUILDER_VALUE(VkSurfacePresentScalingCapabilitiesEXT, surface_present_scaling_capabilities)
     // No good way to make this a builder value. Each std::vector<VkPresentModeKHR> corresponds to each surface_present_modes
     // element
     std::vector<std::vector<VkPresentModeKHR>> surface_present_mode_compatibility{};
 
-    BUILDER_VECTOR(PhysicalDevice, VkDisplayPropertiesKHR, display_properties, display_properties)
-    BUILDER_VECTOR(PhysicalDevice, VkDisplayPlanePropertiesKHR, display_plane_properties, display_plane_properties)
-    BUILDER_VECTOR(PhysicalDevice, VkDisplayKHR, displays, displays)
-    BUILDER_VECTOR(PhysicalDevice, VkDisplayModePropertiesKHR, display_mode_properties, display_mode_properties)
-    BUILDER_VALUE(PhysicalDevice, VkDisplayModeKHR, display_mode, {})
-    BUILDER_VALUE(PhysicalDevice, VkDisplayPlaneCapabilitiesKHR, display_plane_capabilities, {})
+    BUILDER_VECTOR(VkDisplayPropertiesKHR, display_properties, display_properties)
+    BUILDER_VECTOR(VkDisplayPlanePropertiesKHR, display_plane_properties, display_plane_properties)
+    BUILDER_VECTOR(VkDisplayKHR, displays, displays)
+    BUILDER_VECTOR(VkDisplayModePropertiesKHR, display_mode_properties, display_mode_properties)
+    BUILDER_VALUE(VkDisplayModeKHR, display_mode)
+    BUILDER_VALUE(VkDisplayPlaneCapabilitiesKHR, display_plane_capabilities)
 
-    BUILDER_VALUE(PhysicalDevice, VkLayeredDriverUnderlyingApiMSFT, layered_driver_underlying_api,
-                  VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT)
+    BUILDER_VALUE_WITH_DEFAULT(VkLayeredDriverUnderlyingApiMSFT, layered_driver_underlying_api,
+                               VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT)
 
     PhysicalDevice& set_api_version(uint32_t version) {
         properties.apiVersion = version;
@@ -128,12 +128,12 @@ struct PhysicalDevice {
     // Unknown physical device functions. Add a `VulkanFunction` to this list which will be searched in
     // vkGetInstanceProcAddr for custom_instance_functions and vk_icdGetPhysicalDeviceProcAddr for custom_physical_device_functions.
     // To add unknown device functions, add it to the PhysicalDevice directly (in the known_device_functions member)
-    BUILDER_VECTOR(PhysicalDevice, VulkanFunction, custom_physical_device_functions, custom_physical_device_function)
+    BUILDER_VECTOR(VulkanFunction, custom_physical_device_functions, custom_physical_device_function)
 
     // List of function names which are 'known' to the physical device but have test defined implementations
     // The purpose of this list is so that vkGetDeviceProcAddr returns 'a real function pointer' in tests
     // without actually implementing any of the logic inside of it.
-    BUILDER_VECTOR(PhysicalDevice, VulkanFunction, known_device_functions, device_function)
+    BUILDER_VECTOR(VulkanFunction, known_device_functions, device_function)
 };
 
 struct PhysicalDeviceGroup {
@@ -154,25 +154,25 @@ struct PhysicalDeviceGroup {
 struct TestICD {
     std::filesystem::path manifest_file_path;
 
-    BUILDER_VALUE(TestICD, bool, exposes_vk_icdNegotiateLoaderICDInterfaceVersion, true)
-    BUILDER_VALUE(TestICD, bool, exposes_vkEnumerateInstanceExtensionProperties, true)
-    BUILDER_VALUE(TestICD, bool, exposes_vkCreateInstance, true)
-    BUILDER_VALUE(TestICD, bool, exposes_vk_icdGetPhysicalDeviceProcAddr, true)
+    BUILDER_VALUE_WITH_DEFAULT(bool, exposes_vk_icdNegotiateLoaderICDInterfaceVersion, true)
+    BUILDER_VALUE_WITH_DEFAULT(bool, exposes_vkEnumerateInstanceExtensionProperties, true)
+    BUILDER_VALUE_WITH_DEFAULT(bool, exposes_vkCreateInstance, true)
+    BUILDER_VALUE_WITH_DEFAULT(bool, exposes_vk_icdGetPhysicalDeviceProcAddr, true)
 #if defined(WIN32)
-    BUILDER_VALUE(TestICD, bool, exposes_vk_icdEnumerateAdapterPhysicalDevices, true)
+    BUILDER_VALUE_WITH_DEFAULT(bool, exposes_vk_icdEnumerateAdapterPhysicalDevices, true)
 #endif
 
     CalledICDGIPA called_vk_icd_gipa = CalledICDGIPA::not_called;
     CalledNegotiateInterface called_negotiate_interface = CalledNegotiateInterface::not_called;
 
     InterfaceVersionCheck interface_version_check = InterfaceVersionCheck::not_called;
-    BUILDER_VALUE(TestICD, uint32_t, min_icd_interface_version, 0)
-    BUILDER_VALUE(TestICD, uint32_t, max_icd_interface_version, 7)
+    BUILDER_VALUE_WITH_DEFAULT(uint32_t, min_icd_interface_version, 0)
+    BUILDER_VALUE_WITH_DEFAULT(uint32_t, max_icd_interface_version, 7)
     uint32_t icd_interface_version_received = 0;
 
     bool called_enumerate_adapter_physical_devices = false;
 
-    BUILDER_VALUE(TestICD, bool, enable_icd_wsi, false);
+    BUILDER_VALUE(bool, enable_icd_wsi);
     bool is_using_icd_wsi = false;
 
     TestICD& setup_WSI(const char* api_selection = nullptr) {
@@ -182,14 +182,14 @@ struct TestICD {
         return *this;
     }
 
-    BUILDER_VALUE(TestICD, uint32_t, icd_api_version, VK_API_VERSION_1_0)
-    BUILDER_VECTOR(TestICD, LayerDefinition, instance_layers, instance_layer)
-    BUILDER_VECTOR(TestICD, Extension, instance_extensions, instance_extension)
+    BUILDER_VALUE_WITH_DEFAULT(uint32_t, icd_api_version, VK_API_VERSION_1_0)
+    BUILDER_VECTOR(LayerDefinition, instance_layers, instance_layer)
+    BUILDER_VECTOR(Extension, instance_extensions, instance_extension)
     std::vector<Extension> enabled_instance_extensions;
 
-    BUILDER_VECTOR_MOVE_ONLY(TestICD, PhysicalDevice, physical_devices, physical_device);
+    BUILDER_VECTOR_MOVE_ONLY(PhysicalDevice, physical_devices, physical_device);
 
-    BUILDER_VECTOR(TestICD, PhysicalDeviceGroup, physical_device_groups, physical_device_group);
+    BUILDER_VECTOR(PhysicalDeviceGroup, physical_device_groups, physical_device_group);
 
     DispatchableHandle<VkInstance> instance_handle;
     std::vector<DispatchableHandle<VkDevice>> device_handles;
@@ -198,27 +198,27 @@ struct TestICD {
     std::vector<uint64_t> callback_handles;
     std::vector<uint64_t> swapchain_handles;
 
-    BUILDER_VALUE(TestICD, bool, can_query_vkEnumerateInstanceVersion, true);
-    BUILDER_VALUE(TestICD, bool, can_query_GetPhysicalDeviceFuncs, true);
+    BUILDER_VALUE_WITH_DEFAULT(bool, can_query_vkEnumerateInstanceVersion, true);
+    BUILDER_VALUE_WITH_DEFAULT(bool, can_query_GetPhysicalDeviceFuncs, true);
 
     // Unknown instance functions Add a `VulkanFunction` to this list which will be searched in
     // vkGetInstanceProcAddr for custom_instance_functions and vk_icdGetPhysicalDeviceProcAddr for
     // custom_physical_device_functions. To add unknown device functions, add it to the PhysicalDevice directly (in the
     // known_device_functions member)
-    BUILDER_VECTOR(TestICD, VulkanFunction, custom_instance_functions, custom_instance_function)
+    BUILDER_VECTOR(VulkanFunction, custom_instance_functions, custom_instance_function)
 
     // Must explicitely state support for the tooling info extension, that way we can control if vkGetInstanceProcAddr returns a
     // function pointer for vkGetPhysicalDeviceToolPropertiesEXT or vkGetPhysicalDeviceToolProperties (core version)
-    BUILDER_VALUE(TestICD, bool, supports_tooling_info_ext, false);
-    BUILDER_VALUE(TestICD, bool, supports_tooling_info_core, false);
+    BUILDER_VALUE(bool, supports_tooling_info_ext);
+    BUILDER_VALUE(bool, supports_tooling_info_core);
     // List of tooling properties that this driver 'supports'
-    BUILDER_VECTOR(TestICD, VkPhysicalDeviceToolPropertiesEXT, tooling_properties, tooling_property)
+    BUILDER_VECTOR(VkPhysicalDeviceToolPropertiesEXT, tooling_properties, tooling_property)
     std::vector<DispatchableHandle<VkCommandBuffer>> allocated_command_buffers;
 
     VkInstanceCreateFlags passed_in_instance_create_flags{};
 
-    BUILDER_VALUE(TestICD, VkResult, enum_physical_devices_return_code, VK_SUCCESS);
-    BUILDER_VALUE(TestICD, VkResult, enum_adapter_physical_devices_return_code, VK_SUCCESS);
+    BUILDER_VALUE_WITH_DEFAULT(VkResult, enum_physical_devices_return_code, VK_SUCCESS);
+    BUILDER_VALUE_WITH_DEFAULT(VkResult, enum_adapter_physical_devices_return_code, VK_SUCCESS);
 
     PhysicalDevice& GetPhysDevice(VkPhysicalDevice physicalDevice) {
         for (auto& phys_dev : physical_devices) {
@@ -258,7 +258,7 @@ struct TestICD {
     }
 
 #if defined(WIN32)
-    BUILDER_VALUE(TestICD, LUID, adapterLUID, {})
+    BUILDER_VALUE(LUID, adapterLUID)
 #endif  // defined(WIN32)
 };
 

tests/framework/layer/layer_util.h

@@ -30,11 +30,11 @@
 #include "test_util.h"
 
 struct LayerDefinition {
-    BUILDER_VALUE(LayerDefinition, std::string, layerName, {})
-    BUILDER_VALUE(LayerDefinition, uint32_t, specVersion, VK_API_VERSION_1_0)
-    BUILDER_VALUE(LayerDefinition, uint32_t, implementationVersion, VK_API_VERSION_1_0)
-    BUILDER_VALUE(LayerDefinition, std::string, description, {})
-    BUILDER_VECTOR(LayerDefinition, Extension, extensions, extension)
+    BUILDER_VALUE(std::string, layerName)
+    BUILDER_VALUE_WITH_DEFAULT(uint32_t, specVersion, VK_API_VERSION_1_0)
+    BUILDER_VALUE_WITH_DEFAULT(uint32_t, implementationVersion, VK_API_VERSION_1_0)
+    BUILDER_VALUE(std::string, description)
+    BUILDER_VECTOR(Extension, extensions, extension)
 
     VkLayerProperties get() const noexcept {
         VkLayerProperties props{};