From 8f00a90c1c60fe87327de7670ca817c5a42957fa Mon Sep 17 00:00:00 2001 From: Pyry Haulos Date: Mon, 14 Mar 2016 14:39:42 -0700 Subject: [PATCH] Extend and clean up VkSurfaceKHR tests Change-Id: Ieac244ffbdf6834644f2172e1c63d42d9126cecc --- external/vulkancts/framework/vulkan/vkWsiUtil.cpp | 42 ++- external/vulkancts/framework/vulkan/vkWsiUtil.hpp | 66 ++-- .../modules/vulkan/wsi/vktWsiSurfaceTests.cpp | 394 ++++++++++++++------- 3 files changed, 343 insertions(+), 159 deletions(-) diff --git a/external/vulkancts/framework/vulkan/vkWsiUtil.cpp b/external/vulkancts/framework/vulkan/vkWsiUtil.cpp index 650c507..3f599c9 100644 --- a/external/vulkancts/framework/vulkan/vkWsiUtil.cpp +++ b/external/vulkancts/framework/vulkan/vkWsiUtil.cpp @@ -96,7 +96,7 @@ const PlatformProperties& getPlatformProperties (Type wsiType) }, // VK_KHR_wayland_surface { - PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE|PlatformProperties::FEATURE_RESIZE_WINDOW, + 0u, PlatformProperties::SWAPCHAIN_EXTENT_SETS_WINDOW_SIZE, noDisplayLimit, noWindowLimit, @@ -277,5 +277,45 @@ VkSurfaceCapabilitiesKHR getPhysicalDeviceSurfaceCapabilities (const InstanceInt return capabilities; } +std::vector getPhysicalDeviceSurfaceFormats (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface) +{ + deUint32 numFormats = 0; + + VK_CHECK(vki.getPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &numFormats, DE_NULL)); + + if (numFormats > 0) + { + std::vector formats (numFormats); + + VK_CHECK(vki.getPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &numFormats, &formats[0])); + + return formats; + } + else + return std::vector(); +} + +std::vector getPhysicalDeviceSurfacePresentModes (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface) +{ + deUint32 numModes = 0; + + VK_CHECK(vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numModes, DE_NULL)); + + if (numModes > 0) + { + std::vector modes (numModes); + + VK_CHECK(vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numModes, &modes[0])); + + return modes; + } + else + return std::vector(); +} + } // wsi } // vk diff --git a/external/vulkancts/framework/vulkan/vkWsiUtil.hpp b/external/vulkancts/framework/vulkan/vkWsiUtil.hpp index f8171eb..5ec1ab6 100644 --- a/external/vulkancts/framework/vulkan/vkWsiUtil.hpp +++ b/external/vulkancts/framework/vulkan/vkWsiUtil.hpp @@ -34,6 +34,8 @@ #include "vkWsiPlatform.hpp" #include "vkRef.hpp" +#include + namespace vk { namespace wsi @@ -62,34 +64,42 @@ struct PlatformProperties deUint32 maxWindowsPerDisplay; }; -const char* getName (Type wsiType); -const char* getExtensionName (Type wsiType); - -const PlatformProperties& getPlatformProperties (Type wsiType); - -VkResult createSurface (const InstanceInterface& vki, - VkInstance instance, - Type wsiType, - const Display& nativeDisplay, - const Window& nativeWindow, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -Move createSurface (const InstanceInterface& vki, - VkInstance instance, - Type wsiType, - const Display& nativeDisplay, - const Window& nativeWindow, - const VkAllocationCallbacks* pAllocator = DE_NULL); - -VkBool32 getPhysicalDeviceSurfaceSupport (const InstanceInterface& vki, - VkPhysicalDevice physicalDevice, - deUint32 queueFamilyIndex, - VkSurfaceKHR surface); - -VkSurfaceCapabilitiesKHR getPhysicalDeviceSurfaceCapabilities (const InstanceInterface& vki, - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface); +const char* getName (Type wsiType); +const char* getExtensionName (Type wsiType); + +const PlatformProperties& getPlatformProperties (Type wsiType); + +VkResult createSurface (const InstanceInterface& vki, + VkInstance instance, + Type wsiType, + const Display& nativeDisplay, + const Window& nativeWindow, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +Move createSurface (const InstanceInterface& vki, + VkInstance instance, + Type wsiType, + const Display& nativeDisplay, + const Window& nativeWindow, + const VkAllocationCallbacks* pAllocator = DE_NULL); + +VkBool32 getPhysicalDeviceSurfaceSupport (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + deUint32 queueFamilyIndex, + VkSurfaceKHR surface); + +VkSurfaceCapabilitiesKHR getPhysicalDeviceSurfaceCapabilities (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface); + +std::vector getPhysicalDeviceSurfaceFormats (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface); + +std::vector getPhysicalDeviceSurfacePresentModes (const InstanceInterface& vki, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface); } // wsi } // vk diff --git a/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp b/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp index 86b8b93..29b8973 100644 --- a/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp +++ b/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp @@ -54,6 +54,21 @@ #include "deUniquePtr.hpp" #include "deStringUtil.hpp" +namespace vk +{ + +inline bool operator!= (const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR& b) +{ + return (a.format != b.format) || (a.colorSpace != b.colorSpace); +} + +inline bool operator== (const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR& b) +{ + return !(a != b); +} + +} // vk + namespace vkt { namespace wsi @@ -69,6 +84,9 @@ using tcu::TestLog; using tcu::Maybe; using tcu::UVec2; +using de::MovePtr; +using de::UniquePtr; + using std::string; using std::vector; @@ -77,12 +95,12 @@ enum SURFACE_EXTENT_DETERMINED_BY_SWAPCHAIN_MAGIC = 0xffffffff }; -void checkInstanceGlobalExtensionSupport (const PlatformInterface& vkp, const vector& extensionNames) -{ - const vector supportedExtensions = enumerateInstanceExtensionProperties(vkp, DE_NULL); +typedef vector Extensions; - for (vector::const_iterator requiredExtName = extensionNames.begin(); - requiredExtName != extensionNames.end(); +void checkAllSupported (const Extensions& supportedExtensions, const vector& requiredExtensions) +{ + for (vector::const_iterator requiredExtName = requiredExtensions.begin(); + requiredExtName != requiredExtensions.end(); ++requiredExtName) { if (!isExtensionSupported(supportedExtensions, RequiredExtension(*requiredExtName))) @@ -90,34 +108,90 @@ void checkInstanceGlobalExtensionSupport (const PlatformInterface& vkp, const ve } } -Move createInstanceWithWsi (const PlatformInterface& vkp, Type wsiType) +Move createInstanceWithWsi (const PlatformInterface& vkp, + const Extensions& supportedExtensions, + Type wsiType) { vector extensions; extensions.push_back("VK_KHR_surface"); extensions.push_back(getExtensionName(wsiType)); - checkInstanceGlobalExtensionSupport(vkp, extensions); + checkAllSupported(supportedExtensions, extensions); return createDefaultInstance(vkp, vector(), extensions); } -tcu::TestStatus createSurfaceTest (Context& context, Type wsiType) +struct InstanceHelper { - const vk::Platform& vkPlatform = context.getTestContext().getPlatform().getVulkanPlatform(); - const Unique instance (createInstanceWithWsi(context.getPlatformInterface(), wsiType)); - const InstanceDriver vki (context.getPlatformInterface(), *instance); + const vector supportedExtensions; + Unique instance; + const InstanceDriver vki; + + InstanceHelper (Context& context, Type wsiType) + : supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(), + DE_NULL)) + , instance (createInstanceWithWsi(context.getPlatformInterface(), + supportedExtensions, + wsiType)) + , vki (context.getPlatformInterface(), *instance) + {} +}; +MovePtr createDisplay (const vk::Platform& platform, + const Extensions& supportedExtensions, + Type wsiType) +{ try { - const de::UniquePtr nativeDisplay (vkPlatform.createWsiDisplay(wsiType)); - const de::UniquePtr nativeWindow (nativeDisplay->createWindow()); - const Unique surface (createSurface(vki, *instance, wsiType, *nativeDisplay, *nativeWindow)); + return MovePtr(platform.createWsiDisplay(wsiType)); } - catch (const tcu::NotSupportedError&) + catch (const tcu::NotSupportedError& e) { - return tcu::TestStatus::fail("Platform support for WSI not implemented"); + if (isExtensionSupported(supportedExtensions, RequiredExtension(getExtensionName(wsiType)))) + { + // If VK_KHR_{platform}_surface was supported, vk::Platform implementation + // must support creating native display & window for that WSI type. + throw tcu::TestError(e.getMessage()); + } + else + throw; + } +} + +MovePtr createWindow (const Display& display, const Maybe& initialSize) +{ + try + { + return MovePtr(display.createWindow(initialSize)); + } + catch (const tcu::NotSupportedError& e) + { + // See createDisplay - assuming that wsi::Display was supported platform port + // should also support creating a window. + throw tcu::TestError(e.getMessage()); } +} + +struct NativeObjects +{ + const UniquePtr display; + const UniquePtr window; + + NativeObjects (Context& context, + const Extensions& supportedExtensions, + Type wsiType, + const Maybe& initialWindowSize = tcu::nothing()) + : display (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), supportedExtensions, wsiType)) + , window (createWindow(*display, initialWindowSize)) + {} +}; + +tcu::TestStatus createSurfaceTest (Context& context, Type wsiType) +{ + const InstanceHelper instHelper (context, wsiType); + const NativeObjects native (context, instHelper.supportedExtensions, wsiType); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window)); return tcu::TestStatus::pass("Creating surface succeeded"); } @@ -133,49 +207,36 @@ deUint32 getNumQueueFamilies (const InstanceInterface& vki, VkPhysicalDevice phy tcu::TestStatus querySurfaceSupportTest (Context& context, Type wsiType) { - tcu::TestLog& log = context.getTestContext().getLog(); - const vk::Platform& vkPlatform = context.getTestContext().getPlatform().getVulkanPlatform(); - const Unique instance (createInstanceWithWsi(context.getPlatformInterface(), wsiType)); - const InstanceDriver vki (context.getPlatformInterface(), *instance); + tcu::TestLog& log = context.getTestContext().getLog(); + tcu::ResultCollector results (log); + + const InstanceHelper instHelper (context, wsiType); + const NativeObjects native (context, instHelper.supportedExtensions, wsiType); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window)); + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); // On Android surface must be supported by all devices and queue families - const bool expectSupportedOnAll = wsiType == TYPE_ANDROID; + const bool expectSupportedOnAll = wsiType == TYPE_ANDROID; - try + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) { - const de::UniquePtr nativeDisplay (vkPlatform.createWsiDisplay(wsiType)); - const de::UniquePtr nativeWindow (nativeDisplay->createWindow()); - const Unique surface (createSurface(vki, *instance, wsiType, *nativeDisplay, *nativeWindow)); + const VkPhysicalDevice physicalDevice = physicalDevices[deviceNdx]; + const deUint32 numQueueFamilies = getNumQueueFamilies(instHelper.vki, physicalDevice); + for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < numQueueFamilies; ++queueFamilyNdx) { - const vector physicalDevices = enumeratePhysicalDevices(vki, *instance); - tcu::ResultCollector results (log); - - for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) - { - const VkPhysicalDevice physicalDevice = physicalDevices[deviceNdx]; - const deUint32 numQueueFamilies = getNumQueueFamilies(vki, physicalDevice); + const VkBool32 isSupported = getPhysicalDeviceSurfaceSupport(instHelper.vki, physicalDevice, queueFamilyNdx, *surface); - for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < numQueueFamilies; ++queueFamilyNdx) - { - const VkBool32 isSupported = getPhysicalDeviceSurfaceSupport(vki, physicalDevice, queueFamilyNdx, *surface); + log << TestLog::Message << "Device " << deviceNdx << ", queue family " << queueFamilyNdx << ": " + << (isSupported == VK_FALSE ? "NOT " : "") << "supported" + << TestLog::EndMessage; - log << TestLog::Message << "Device " << deviceNdx << ", queue family " << queueFamilyNdx << ": " - << (isSupported == VK_FALSE ? "NOT " : "") << "supported" - << TestLog::EndMessage; - - if (expectSupportedOnAll && !isSupported) - results.fail("Surface must be supported by all devices and queue families"); - } - } - - return tcu::TestStatus(results.getResult(), results.getMessage()); + if (expectSupportedOnAll && !isSupported) + results.fail("Surface must be supported by all devices and queue families"); } } - catch (const tcu::NotSupportedError&) - { - return tcu::TestStatus::fail("Platform support for WSI not implemented"); - } + + return tcu::TestStatus(results.getResult(), results.getMessage()); } bool isSupportedByAnyQueue (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface) @@ -241,51 +302,135 @@ void validateSurfaceCapabilities (tcu::ResultCollector& results, const VkSurface tcu::TestStatus querySurfaceCapabilitiesTest (Context& context, Type wsiType) { - const vk::Platform& vkPlatform = context.getTestContext().getPlatform().getVulkanPlatform(); - const Unique instance (createInstanceWithWsi(context.getPlatformInterface(), wsiType)); - const InstanceDriver vki (context.getPlatformInterface(), *instance); - tcu::TestLog& log = context.getTestContext().getLog(); + tcu::TestLog& log = context.getTestContext().getLog(); + tcu::ResultCollector results (log); - try + const InstanceHelper instHelper (context, wsiType); + const NativeObjects native (context, instHelper.supportedExtensions, wsiType); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window)); + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); + + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) { - const de::UniquePtr nativeDisplay (vkPlatform.createWsiDisplay(wsiType)); - const de::UniquePtr nativeWindow (nativeDisplay->createWindow()); - const Unique surface (createSurface(vki, *instance, wsiType, *nativeDisplay, *nativeWindow)); + if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface)) + { + const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, + physicalDevices[deviceNdx], + *surface); + + log << TestLog::Message << "Device " << deviceNdx << ": " << capabilities << TestLog::EndMessage; + + validateSurfaceCapabilities(results, capabilities); + } + // else skip query as surface is not supported by the device + } + return tcu::TestStatus(results.getResult(), results.getMessage()); +} + +void validateSurfaceFormats (tcu::ResultCollector& results, Type wsiType, const vector& formats) +{ + const VkSurfaceFormatKHR* requiredFormats = DE_NULL; + size_t numRequiredFormats = 0; + + if (wsiType == TYPE_ANDROID) + { + static const VkSurfaceFormatKHR s_androidFormats[] = { - const vector physicalDevices = enumeratePhysicalDevices(vki, *instance); - tcu::ResultCollector results (log); + { VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR }, + { VK_FORMAT_R8G8B8A8_SRGB, VK_COLORSPACE_SRGB_NONLINEAR_KHR }, + { VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLORSPACE_SRGB_NONLINEAR_KHR } + }; - for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) - { - if (isSupportedByAnyQueue(vki, physicalDevices[deviceNdx], *surface)) - { - const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(vki, physicalDevices[deviceNdx], *surface); + requiredFormats = &s_androidFormats[0]; + numRequiredFormats = DE_LENGTH_OF_ARRAY(s_androidFormats); + } - log << TestLog::Message << "Device " << deviceNdx << ": " << capabilities << TestLog::EndMessage; + for (size_t ndx = 0; ndx < numRequiredFormats; ++ndx) + { + const VkSurfaceFormatKHR& requiredFormat = requiredFormats[ndx]; - validateSurfaceCapabilities(results, capabilities); - } - // else skip query as surface is not supported by the device - } + if (!de::contains(formats.begin(), formats.end(), requiredFormat)) + results.fail(de::toString(requiredFormat) + " not supported"); + } +} + +tcu::TestStatus querySurfaceFormatsTest (Context& context, Type wsiType) +{ + tcu::TestLog& log = context.getTestContext().getLog(); + tcu::ResultCollector results (log); + + const InstanceHelper instHelper (context, wsiType); + const NativeObjects native (context, instHelper.supportedExtensions, wsiType); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window)); + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); + + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) + { + if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface)) + { + const vector formats = getPhysicalDeviceSurfaceFormats(instHelper.vki, + physicalDevices[deviceNdx], + *surface); + + log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(formats.begin(), formats.end()) << TestLog::EndMessage; - return tcu::TestStatus(results.getResult(), results.getMessage()); + validateSurfaceFormats(results, wsiType, formats); } + // else skip query as surface is not supported by the device } - catch (const tcu::NotSupportedError&) + + return tcu::TestStatus(results.getResult(), results.getMessage()); +} + +void validateSurfacePresentModes (tcu::ResultCollector& results, Type wsiType, const vector& modes) +{ + results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_FIFO_KHR), + "VK_PRESENT_MODE_FIFO_KHR is not supported"); + + if (wsiType == TYPE_ANDROID) + results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_MAILBOX_KHR), + "VK_PRESENT_MODE_MAILBOX_KHR is not supported"); +} + +tcu::TestStatus querySurfacePresentModesTest (Context& context, Type wsiType) +{ + tcu::TestLog& log = context.getTestContext().getLog(); + tcu::ResultCollector results (log); + + const InstanceHelper instHelper (context, wsiType); + const NativeObjects native (context, instHelper.supportedExtensions, wsiType); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window)); + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); + + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) { - return tcu::TestStatus::fail("Platform support for WSI not implemented"); + if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface)) + { + const vector modes = getPhysicalDeviceSurfacePresentModes(instHelper.vki, physicalDevices[deviceNdx], *surface); + + log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(modes.begin(), modes.end()) << TestLog::EndMessage; + + validateSurfacePresentModes(results, wsiType, modes); + } + // else skip query as surface is not supported by the device } + + return tcu::TestStatus(results.getResult(), results.getMessage()); } tcu::TestStatus createSurfaceInitialSizeTest (Context& context, Type wsiType) { - const vk::Platform& vkPlatform = context.getTestContext().getPlatform().getVulkanPlatform(); - const Unique instance (createInstanceWithWsi(context.getPlatformInterface(), wsiType)); - const InstanceDriver vki (context.getPlatformInterface(), *instance); - const vector physicalDevices = enumeratePhysicalDevices(vki, *instance); tcu::TestLog& log = context.getTestContext().getLog(); tcu::ResultCollector results (log); + + const InstanceHelper instHelper (context, wsiType); + + const UniquePtr nativeDisplay (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), + instHelper.supportedExtensions, + wsiType)); + + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); const UVec2 sizes[] = { UVec2(64, 64), @@ -295,46 +440,44 @@ tcu::TestStatus createSurfaceInitialSizeTest (Context& context, Type wsiType) DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE); - try + for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx) { - const de::UniquePtr nativeDisplay (vkPlatform.createWsiDisplay(wsiType)); + const UVec2& testSize = sizes[sizeNdx]; + const UniquePtr nativeWindow (createWindow(*nativeDisplay, tcu::just(testSize))); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow)); - for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx) + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) { - const UVec2 testSize = sizes[sizeNdx]; - const de::UniquePtr nativeWindow (nativeDisplay->createWindow(tcu::just(testSize))); - const Unique surface (createSurface(vki, *instance, wsiType, *nativeDisplay, *nativeWindow)); - - for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) + if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface)) { - if (isSupportedByAnyQueue(vki, physicalDevices[deviceNdx], *surface)) - { - const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(vki, physicalDevices[deviceNdx], *surface); - - // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform - results.check(capabilities.currentExtent.width == testSize.x() && - capabilities.currentExtent.height == testSize.y(), - "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize)); - } + const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface); + + // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform + results.check(capabilities.currentExtent.width == testSize.x() && + capabilities.currentExtent.height == testSize.y(), + "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize)); } } } - catch (const tcu::NotSupportedError&) - { - return tcu::TestStatus::fail("Platform support for WSI not implemented"); - } return tcu::TestStatus(results.getResult(), results.getMessage()); } tcu::TestStatus resizeSurfaceTest (Context& context, Type wsiType) { - const vk::Platform& vkPlatform = context.getTestContext().getPlatform().getVulkanPlatform(); - const Unique instance (createInstanceWithWsi(context.getPlatformInterface(), wsiType)); - const InstanceDriver vki (context.getPlatformInterface(), *instance); - const vector physicalDevices = enumeratePhysicalDevices(vki, *instance); tcu::TestLog& log = context.getTestContext().getLog(); tcu::ResultCollector results (log); + + const InstanceHelper instHelper (context, wsiType); + + const UniquePtr nativeDisplay (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), + instHelper.supportedExtensions, + wsiType)); + UniquePtr nativeWindow (createWindow(*nativeDisplay, tcu::nothing())); + + const vector physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance); + const Unique surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow)); + const UVec2 sizes[] = { UVec2(64, 64), @@ -344,44 +487,33 @@ tcu::TestStatus resizeSurfaceTest (Context& context, Type wsiType) DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_RESIZE_WINDOW); - try + for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx) { - const de::UniquePtr nativeDisplay (vkPlatform.createWsiDisplay(wsiType)); - const de::UniquePtr nativeWindow (nativeDisplay->createWindow()); - const Unique surface (createSurface(vki, *instance, wsiType, *nativeDisplay, *nativeWindow)); + const UVec2 testSize = sizes[sizeNdx]; - for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx) + try { - const UVec2 testSize = sizes[sizeNdx]; + nativeWindow->resize(testSize); + } + catch (const tcu::Exception& e) + { + // Make sure all exception types result in a test failure + results.fail(e.getMessage()); + } - try - { - nativeWindow->resize(testSize); - } - catch (const tcu::Exception& e) + for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) + { + if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface)) { - // Make sure all exception types result in a test failure - results.fail(e.getMessage()); - } + const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface); - for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx) - { - if (isSupportedByAnyQueue(vki, physicalDevices[deviceNdx], *surface)) - { - const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(vki, physicalDevices[deviceNdx], *surface); - - // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform - results.check(capabilities.currentExtent.width == testSize.x() && - capabilities.currentExtent.height == testSize.y(), - "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize)); - } + // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform + results.check(capabilities.currentExtent.width == testSize.x() && + capabilities.currentExtent.height == testSize.y(), + "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize)); } } } - catch (const tcu::NotSupportedError&) - { - return tcu::TestStatus::fail("Platform support for WSI not implemented"); - } return tcu::TestStatus(results.getResult(), results.getMessage()); } @@ -395,6 +527,8 @@ void createSurfaceTests (tcu::TestCaseGroup* testGroup, vk::wsi::Type wsiType) addFunctionCase(testGroup, "create", "Create surface", createSurfaceTest, wsiType); addFunctionCase(testGroup, "query_support", "Query surface support", querySurfaceSupportTest, wsiType); addFunctionCase(testGroup, "query_capabilities", "Query surface capabilities", querySurfaceCapabilitiesTest, wsiType); + addFunctionCase(testGroup, "query_formats", "Query surface formats", querySurfaceFormatsTest, wsiType); + addFunctionCase(testGroup, "query_present_modes", "Query surface present modes", querySurfacePresentModesTest, wsiType); if ((platformProperties.features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE) != 0) addFunctionCase(testGroup, "initial_size", "Create surface with initial window size set", createSurfaceInitialSizeTest, wsiType); -- 2.7.4