external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief VkSurface Tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktWsiSurfaceTests.hpp"
  25
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktTestGroupUtil.hpp"
  28
  29 #include "vkDefs.hpp"
  30 #include "vkPlatform.hpp"
  31 #include "vkStrUtil.hpp"
  32 #include "vkRef.hpp"
  33 #include "vkRefUtil.hpp"
  34 #include "vkQueryUtil.hpp"
  35 #include "vkMemUtil.hpp"
  36 #include "vkDeviceUtil.hpp"
  37 #include "vkPrograms.hpp"
  38 #include "vkTypeUtil.hpp"
  39 #include "vkWsiPlatform.hpp"
  40 #include "vkWsiUtil.hpp"
  41 #include "vkAllocationCallbackUtil.hpp"
  42 #include "vkQueryUtil.hpp"
  43
  44 #include "tcuTestLog.hpp"
  45 #include "tcuFormatUtil.hpp"
  46 #include "tcuPlatform.hpp"
  47 #include "tcuResultCollector.hpp"
  48 #include "tcuCommandLine.hpp"
  49
  50 #include "deUniquePtr.hpp"
  51 #include "deStringUtil.hpp"
  52 #include "deMemory.h"
  53
  54 namespace vk
  55 {
  56
  57 inline bool operator!= (const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR& b)
  58 {
  59         return (a.format != b.format) || (a.colorSpace != b.colorSpace);
  60 }
  61
  62 inline bool operator== (const VkSurfaceFormatKHR& a, const VkSurfaceFormatKHR& b)
  63 {
  64         return !(a != b);
  65 }
  66
  67 inline bool operator!= (const VkExtent2D& a, const VkExtent2D& b)
  68 {
  69         return (a.width != b.width) || (a.height != b.height);
  70 }
  71
  72 inline bool operator!= (const VkSurfaceCapabilitiesKHR& a, const VkSurfaceCapabilitiesKHR& b)
  73 {
  74         return (a.minImageCount                         != b.minImageCount)                             ||
  75                    (a.maxImageCount                             != b.maxImageCount)                             ||
  76                    (a.currentExtent                             != b.currentExtent)                             ||
  77                    (a.minImageExtent                    != b.minImageExtent)                    ||
  78                    (a.maxImageExtent                    != b.maxImageExtent)                    ||
  79                    (a.maxImageArrayLayers               != b.maxImageArrayLayers)               ||
  80                    (a.supportedTransforms               != b.supportedTransforms)               ||
  81                    (a.currentTransform                  != b.currentTransform)                  ||
  82                    (a.supportedCompositeAlpha   != b.supportedCompositeAlpha)   ||
  83                    (a.supportedUsageFlags               != b.supportedUsageFlags);
  84 }
  85
  86 } // vk
  87
  88 namespace vkt
  89 {
  90 namespace wsi
  91 {
  92
  93 namespace
  94 {
  95
  96 using namespace vk;
  97 using namespace vk::wsi;
  98
  99 using tcu::TestLog;
 100 using tcu::Maybe;
 101 using tcu::UVec2;
 102
 103 using de::MovePtr;
 104 using de::UniquePtr;
 105
 106 using std::string;
 107 using std::vector;
 108
 109 enum
 110 {
 111         SURFACE_EXTENT_DETERMINED_BY_SWAPCHAIN_MAGIC    = 0xffffffff
 112 };
 113
 114 enum
 115 {
 116         GUARD_SIZE                                                                              = 0x20,                 //!< Number of bytes to check
 117         GUARD_VALUE                                                                             = 0xcd,                 //!< Data pattern
 118 };
 119
 120 template<typename T>
 121 class CheckIncompleteResult
 122 {
 123 public:
 124         virtual                 ~CheckIncompleteResult  (void) {}
 125         virtual void    getResult                               (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkSurfaceKHR surface, T* data) = 0;
 126
 127         void operator() (tcu::ResultCollector&          results,
 128                                          const InstanceInterface&       vki,
 129                                          const VkPhysicalDevice         physDevice,
 130                                          const VkSurfaceKHR                     surface,
 131                                          const std::size_t                      expectedCompleteSize)
 132         {
 133                 if (expectedCompleteSize == 0)
 134                         return;
 135
 136                 vector<T>               outputData      (expectedCompleteSize);
 137                 const deUint32  usedSize        = static_cast<deUint32>(expectedCompleteSize / 3);
 138
 139                 ValidateQueryBits::fillBits(outputData.begin(), outputData.end());      // unused entries should have this pattern intact
 140                 m_count         = usedSize;
 141                 m_result        = VK_SUCCESS;
 142
 143                 getResult(vki, physDevice, surface, &outputData[0]);                            // update m_count and m_result
 144
 145                 if (m_count != usedSize || m_result != VK_INCOMPLETE || !ValidateQueryBits::checkBits(outputData.begin() + m_count, outputData.end()))
 146                         results.fail("Query didn't return VK_INCOMPLETE");
 147         }
 148
 149 protected:
 150         deUint32        m_count;
 151         VkResult        m_result;
 152 };
 153
 154 struct CheckPhysicalDeviceSurfaceFormatsIncompleteResult : public CheckIncompleteResult<VkSurfaceFormatKHR>
 155 {
 156         void getResult (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkSurfaceKHR surface, VkSurfaceFormatKHR* data)
 157         {
 158                 m_result = vki.getPhysicalDeviceSurfaceFormatsKHR(physDevice, surface, &m_count, data);
 159         }
 160 };
 161
 162 struct CheckPhysicalDeviceSurfacePresentModesIncompleteResult : public CheckIncompleteResult<VkPresentModeKHR>
 163 {
 164         void getResult (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkSurfaceKHR surface, VkPresentModeKHR* data)
 165         {
 166                 m_result = vki.getPhysicalDeviceSurfacePresentModesKHR(physDevice, surface, &m_count, data);
 167         }
 168 };
 169
 170 typedef vector<VkExtensionProperties> Extensions;
 171
 172 Move<VkInstance> createInstanceWithWsi (const PlatformInterface&                vkp,
 173                                                                                 deUint32                                                version,
 174                                                                                 const Extensions&                               supportedExtensions,
 175                                                                                 Type                                                    wsiType,
 176                                                                                 const vector<string>                    extraExtensions,
 177                                                                                 const VkAllocationCallbacks*    pAllocator      = DE_NULL)
 178 {
 179         vector<string>  extensions = extraExtensions;
 180
 181         extensions.push_back("VK_KHR_surface");
 182         extensions.push_back(getExtensionName(wsiType));
 183
 184         vector<string>  instanceExtensions;
 185
 186         for (vector<string>::const_iterator extensionName = extensions.begin();
 187                  extensionName != extensions.end();
 188                  ++extensionName)
 189         {
 190                 if (!isInstanceExtensionSupported(version, supportedExtensions, RequiredExtension(*extensionName)))
 191                         TCU_THROW(NotSupportedError, (*extensionName + " is not supported").c_str());
 192
 193                 if (!isCoreInstanceExtension(version, *extensionName))
 194                         instanceExtensions.push_back(*extensionName);
 195         }
 196
 197         return vk::createDefaultInstance(vkp, version, vector<string>(), instanceExtensions, pAllocator);
 198 }
 199
 200 struct InstanceHelper
 201 {
 202         const vector<VkExtensionProperties>     supportedExtensions;
 203         Unique<VkInstance>                                      instance;
 204         const InstanceDriver                            vki;
 205
 206         InstanceHelper (Context& context, Type wsiType, const VkAllocationCallbacks* pAllocator = DE_NULL)
 207                 : supportedExtensions   (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
 208                                                                                                                                           DE_NULL))
 209                 , instance                              (createInstanceWithWsi(context.getPlatformInterface(),
 210                                                                                                            context.getUsedApiVersion(),
 211                                                                                                            supportedExtensions,
 212                                                                                                            wsiType,
 213                                                                                                            vector<string>(),
 214                                                                                                            pAllocator))
 215                 , vki                                   (context.getPlatformInterface(), *instance)
 216         {}
 217
 218         InstanceHelper (Context& context, Type wsiType, const vector<string>& extensions, const VkAllocationCallbacks* pAllocator = DE_NULL)
 219                 : supportedExtensions   (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
 220                                                                                                                                           DE_NULL))
 221                 , instance                              (createInstanceWithWsi(context.getPlatformInterface(),
 222                                                                                                            context.getUsedApiVersion(),
 223                                                                                                            supportedExtensions,
 224                                                                                                            wsiType,
 225                                                                                                            extensions,
 226                                                                                                            pAllocator))
 227                 , vki                                   (context.getPlatformInterface(), *instance)
 228         {}
 229 };
 230
 231 MovePtr<Display> createDisplay (const vk::Platform&     platform,
 232                                                                 const Extensions&       supportedExtensions,
 233                                                                 Type                            wsiType)
 234 {
 235         try
 236         {
 237                 return MovePtr<Display>(platform.createWsiDisplay(wsiType));
 238         }
 239         catch (const tcu::NotSupportedError& e)
 240         {
 241                 if (isExtensionSupported(supportedExtensions, RequiredExtension(getExtensionName(wsiType))))
 242                 {
 243                         // If VK_KHR_{platform}_surface was supported, vk::Platform implementation
 244                         // must support creating native display & window for that WSI type.
 245                         throw tcu::TestError(e.getMessage());
 246                 }
 247                 else
 248                         throw;
 249         }
 250 }
 251
 252 MovePtr<Window> createWindow (const Display& display, const Maybe<UVec2>& initialSize)
 253 {
 254         try
 255         {
 256                 return MovePtr<Window>(display.createWindow(initialSize));
 257         }
 258         catch (const tcu::NotSupportedError& e)
 259         {
 260                 // See createDisplay - assuming that wsi::Display was supported platform port
 261                 // should also support creating a window.
 262                 throw tcu::TestError(e.getMessage());
 263         }
 264 }
 265
 266 struct NativeObjects
 267 {
 268         const UniquePtr<Display>        display;
 269         const UniquePtr<Window>         window;
 270
 271         NativeObjects (Context&                         context,
 272                                    const Extensions&    supportedExtensions,
 273                                    Type                                 wsiType,
 274                                    const Maybe<UVec2>&  initialWindowSize = tcu::nothing<UVec2>())
 275                 : display       (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), supportedExtensions, wsiType))
 276                 , window        (createWindow(*display, initialWindowSize))
 277         {}
 278 };
 279
 280 tcu::TestStatus createSurfaceTest (Context& context, Type wsiType)
 281 {
 282         const InstanceHelper            instHelper      (context, wsiType);
 283         const NativeObjects                     native          (context, instHelper.supportedExtensions, wsiType);
 284         const Unique<VkSurfaceKHR>      surface         (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 285
 286         return tcu::TestStatus::pass("Creating surface succeeded");
 287 }
 288
 289 tcu::TestStatus createSurfaceCustomAllocatorTest (Context& context, Type wsiType)
 290 {
 291         AllocationCallbackRecorder      allocationRecorder      (getSystemAllocator());
 292         tcu::TestLog&                           log                                     = context.getTestContext().getLog();
 293
 294         {
 295                 const InstanceHelper            instHelper      (context, wsiType, allocationRecorder.getCallbacks());
 296                 const NativeObjects                     native          (context, instHelper.supportedExtensions, wsiType);
 297                 const Unique<VkSurfaceKHR>      surface         (createSurface(instHelper.vki,
 298                                                                                                                            *instHelper.instance,
 299                                                                                                                            wsiType,
 300                                                                                                                            *native.display,
 301                                                                                                                            *native.window,
 302                                                                                                                            allocationRecorder.getCallbacks()));
 303
 304                 if (!validateAndLog(log,
 305                                                         allocationRecorder,
 306                                                         (1u<<VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)         |
 307                                                         (1u<<VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)))
 308                         return tcu::TestStatus::fail("Detected invalid system allocation callback");
 309         }
 310
 311         if (!validateAndLog(log, allocationRecorder, 0u))
 312                 return tcu::TestStatus::fail("Detected invalid system allocation callback");
 313
 314         if (allocationRecorder.getRecordsBegin() == allocationRecorder.getRecordsEnd())
 315                 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Allocation callbacks were not used");
 316         else
 317                 return tcu::TestStatus::pass("Creating surface succeeded using custom allocator");
 318 }
 319
 320 tcu::TestStatus createSurfaceSimulateOOMTest (Context& context, Type wsiType)
 321 {
 322         tcu::TestLog&   log     = context.getTestContext().getLog();
 323
 324         for (deUint32 numPassingAllocs = 0; numPassingAllocs <= 1024u; ++numPassingAllocs)
 325         {
 326                 AllocationCallbackRecorder      allocationRecorder      (getSystemAllocator());
 327                 DeterministicFailAllocator      failingAllocator        (allocationRecorder.getCallbacks(),
 328                                                                                                                  DeterministicFailAllocator::MODE_DO_NOT_COUNT,
 329                                                                                                                  0);
 330                 bool                                            gotOOM                          = false;
 331
 332                 log << TestLog::Message << "Testing with " << numPassingAllocs << " first allocations succeeding" << TestLog::EndMessage;
 333
 334                 try
 335                 {
 336                         const InstanceHelper            instHelper      (context, wsiType, failingAllocator.getCallbacks());
 337
 338                         // OOM is not simulated for VkInstance as we don't want to spend time
 339                         // testing OOM paths inside instance creation.
 340                         failingAllocator.reset(DeterministicFailAllocator::MODE_COUNT_AND_FAIL, numPassingAllocs);
 341
 342                         const NativeObjects                     native          (context, instHelper.supportedExtensions, wsiType);
 343                         const Unique<VkSurfaceKHR>      surface         (createSurface(instHelper.vki,
 344                                                                                                                                    *instHelper.instance,
 345                                                                                                                                    wsiType,
 346                                                                                                                                    *native.display,
 347                                                                                                                                    *native.window,
 348                                                                                                                                    failingAllocator.getCallbacks()));
 349
 350                         if (!validateAndLog(log,
 351                                                                 allocationRecorder,
 352                                                                 (1u<<VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)         |
 353                                                                 (1u<<VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)))
 354                                 return tcu::TestStatus::fail("Detected invalid system allocation callback");
 355                 }
 356                 catch (const OutOfMemoryError& e)
 357                 {
 358                         log << TestLog::Message << "Got " << e.getError() << TestLog::EndMessage;
 359                         gotOOM = true;
 360                 }
 361
 362                 if (!validateAndLog(log, allocationRecorder, 0u))
 363                         return tcu::TestStatus::fail("Detected invalid system allocation callback");
 364
 365                 if (!gotOOM)
 366                 {
 367                         log << TestLog::Message << "Creating surface succeeded!" << TestLog::EndMessage;
 368
 369                         if (numPassingAllocs == 0)
 370                                 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Allocation callbacks were not used");
 371                         else
 372                                 return tcu::TestStatus::pass("OOM simulation completed");
 373                 }
 374         }
 375
 376         return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Creating surface did not succeed, callback limit exceeded");
 377 }
 378
 379 deUint32 getNumQueueFamilies (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
 380 {
 381         deUint32        numFamilies             = 0;
 382
 383         vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numFamilies, DE_NULL);
 384
 385         return numFamilies;
 386 }
 387
 388 tcu::TestStatus querySurfaceSupportTest (Context& context, Type wsiType)
 389 {
 390         tcu::TestLog&                                   log                                             = context.getTestContext().getLog();
 391         tcu::ResultCollector                    results                                 (log);
 392
 393         const InstanceHelper                    instHelper                              (context, wsiType);
 394         const NativeObjects                             native                                  (context, instHelper.supportedExtensions, wsiType);
 395         const Unique<VkSurfaceKHR>              surface                                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 396         const vector<VkPhysicalDevice>  physicalDevices                 = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 397
 398         // On Android surface must be supported by all devices and queue families
 399         const bool                                              expectSupportedOnAll    = wsiType == TYPE_ANDROID;
 400
 401         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 402         {
 403                 const VkPhysicalDevice          physicalDevice          = physicalDevices[deviceNdx];
 404                 const deUint32                          numQueueFamilies        = getNumQueueFamilies(instHelper.vki, physicalDevice);
 405
 406                 for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < numQueueFamilies; ++queueFamilyNdx)
 407                 {
 408                         const VkBool32  isSupported             = getPhysicalDeviceSurfaceSupport(instHelper.vki, physicalDevice, queueFamilyNdx, *surface);
 409
 410                         log << TestLog::Message << "Device " << deviceNdx << ", queue family " << queueFamilyNdx << ": "
 411                                                                         << (isSupported == VK_FALSE ? "NOT " : "") << "supported"
 412                                 << TestLog::EndMessage;
 413
 414                         if (expectSupportedOnAll && !isSupported)
 415                                 results.fail("Surface must be supported by all devices and queue families");
 416                 }
 417         }
 418
 419         return tcu::TestStatus(results.getResult(), results.getMessage());
 420 }
 421
 422 bool isSupportedByAnyQueue (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface)
 423 {
 424         const deUint32  numQueueFamilies        = getNumQueueFamilies(vki, physicalDevice);
 425
 426         for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < numQueueFamilies; ++queueFamilyNdx)
 427         {
 428                 if (getPhysicalDeviceSurfaceSupport(vki, physicalDevice, queueFamilyNdx, surface) != VK_FALSE)
 429                         return true;
 430         }
 431
 432         return false;
 433 }
 434
 435 void validateSurfaceCapabilities (tcu::ResultCollector& results, const VkSurfaceCapabilitiesKHR& capabilities)
 436 {
 437         results.check(capabilities.minImageCount > 0,
 438                                   "minImageCount must be larger than 0");
 439
 440         results.check(capabilities.minImageExtent.width > 0 &&
 441                                   capabilities.minImageExtent.height > 0,
 442                                   "minImageExtent dimensions must be larger than 0");
 443
 444         results.check(capabilities.maxImageExtent.width > 0 &&
 445                                   capabilities.maxImageExtent.height > 0,
 446                                   "maxImageExtent dimensions must be larger than 0");
 447
 448         results.check(capabilities.minImageExtent.width <= capabilities.maxImageExtent.width &&
 449                                   capabilities.minImageExtent.height <= capabilities.maxImageExtent.height,
 450                                   "maxImageExtent must be larger or equal to minImageExtent");
 451
 452         if (capabilities.currentExtent.width != SURFACE_EXTENT_DETERMINED_BY_SWAPCHAIN_MAGIC ||
 453                 capabilities.currentExtent.height != SURFACE_EXTENT_DETERMINED_BY_SWAPCHAIN_MAGIC)
 454         {
 455                 results.check(capabilities.currentExtent.width > 0 &&
 456                                           capabilities.currentExtent.height > 0,
 457                                           "currentExtent dimensions must be larger than 0");
 458
 459                 results.check(de::inRange(capabilities.currentExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width) &&
 460                                           de::inRange(capabilities.currentExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height),
 461                                           "currentExtent is not in supported extent limits");
 462         }
 463
 464         results.check(capabilities.maxImageArrayLayers > 0,
 465                                   "maxImageArrayLayers must be larger than 0");
 466
 467         results.check((capabilities.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) != 0,
 468                                   "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT must be set in supportedUsageFlags");
 469
 470         results.check(capabilities.supportedTransforms != 0,
 471                                   "At least one transform must be supported");
 472
 473         results.check(dePop32(capabilities.currentTransform) != 0,
 474                                   "Invalid currentTransform");
 475
 476         results.check((capabilities.supportedTransforms & capabilities.currentTransform) != 0,
 477                                   "currentTransform is not supported by surface");
 478
 479         results.check(capabilities.supportedCompositeAlpha != 0,
 480                                   "At least one alpha mode must be supported");
 481 }
 482
 483 tcu::TestStatus querySurfaceCapabilitiesTest (Context& context, Type wsiType)
 484 {
 485         tcu::TestLog&                                   log                                             = context.getTestContext().getLog();
 486         tcu::ResultCollector                    results                                 (log);
 487
 488         const InstanceHelper                    instHelper                              (context, wsiType);
 489         const NativeObjects                             native                                  (context, instHelper.supportedExtensions, wsiType);
 490         const Unique<VkSurfaceKHR>              surface                                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 491         const vector<VkPhysicalDevice>  physicalDevices                 = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 492
 493         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 494         {
 495                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 496                 {
 497                         const VkSurfaceCapabilitiesKHR  capabilities    = getPhysicalDeviceSurfaceCapabilities(instHelper.vki,
 498                                                                                                                                                                                                    physicalDevices[deviceNdx],
 499                                                                                                                                                                                                    *surface);
 500
 501                         log << TestLog::Message << "Device " << deviceNdx << ": " << capabilities << TestLog::EndMessage;
 502
 503                         validateSurfaceCapabilities(results, capabilities);
 504                 }
 505                 // else skip query as surface is not supported by the device
 506         }
 507
 508         return tcu::TestStatus(results.getResult(), results.getMessage());
 509 }
 510
 511 tcu::TestStatus querySurfaceCapabilities2Test (Context& context, Type wsiType)
 512 {
 513         tcu::TestLog&                                   log                                             = context.getTestContext().getLog();
 514         tcu::ResultCollector                    results                                 (log);
 515
 516         const InstanceHelper                    instHelper                              (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
 517         const NativeObjects                             native                                  (context, instHelper.supportedExtensions, wsiType);
 518         const Unique<VkSurfaceKHR>              surface                                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 519         const vector<VkPhysicalDevice>  physicalDevices                 = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 520
 521         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 522         {
 523                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 524                 {
 525                         const VkSurfaceCapabilitiesKHR  refCapabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki,
 526                                                                                                                                                                                                    physicalDevices[deviceNdx],
 527                                                                                                                                                                                                    *surface);
 528                         VkSurfaceCapabilities2KHR               extCapabilities;
 529
 530                         deMemset(&extCapabilities, 0xcd, sizeof(VkSurfaceCapabilities2KHR));
 531                         extCapabilities.sType   = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
 532                         extCapabilities.pNext   = DE_NULL;
 533
 534                         {
 535                                 const VkPhysicalDeviceSurfaceInfo2KHR   surfaceInfo     =
 536                                 {
 537                                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
 538                                         DE_NULL,
 539                                         *surface
 540                                 };
 541                                 VkPhysicalDeviceSurfaceInfo2KHR                 infoCopy;
 542
 543                                 deMemcpy(&infoCopy, &surfaceInfo, sizeof(VkPhysicalDeviceSurfaceInfo2KHR));
 544
 545                                 VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevices[deviceNdx], &surfaceInfo, &extCapabilities));
 546
 547                                 results.check(deMemoryEqual(&surfaceInfo, &infoCopy, sizeof(VkPhysicalDeviceSurfaceInfo2KHR)) == DE_TRUE, "Driver wrote into input struct");
 548                         }
 549
 550                         results.check(extCapabilities.sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR &&
 551                                                   extCapabilities.pNext == DE_NULL,
 552                                                   "sType/pNext modified");
 553
 554                         if (refCapabilities != extCapabilities.surfaceCapabilities)
 555                         {
 556                                 log << TestLog::Message
 557                                         << "Device " << deviceNdx
 558                                         << ": expected " << refCapabilities
 559                                         << ", got " << extCapabilities.surfaceCapabilities
 560                                         << TestLog::EndMessage;
 561                                 results.fail("Mismatch between VK_KHR_surface and VK_KHR_surface2 query results");
 562                         }
 563                 }
 564         }
 565
 566         return tcu::TestStatus(results.getResult(), results.getMessage());
 567 }
 568
 569 void validateSurfaceFormats (tcu::ResultCollector& results, Type wsiType, const vector<VkSurfaceFormatKHR>& formats)
 570 {
 571         const VkSurfaceFormatKHR*       requiredFormats         = DE_NULL;
 572         size_t                                          numRequiredFormats      = 0;
 573
 574         if (wsiType == TYPE_ANDROID)
 575         {
 576                 static const VkSurfaceFormatKHR s_androidFormats[] =
 577                 {
 578                         { VK_FORMAT_R8G8B8A8_UNORM,                     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR       },
 579                         { VK_FORMAT_R8G8B8A8_SRGB,                      VK_COLOR_SPACE_SRGB_NONLINEAR_KHR       },
 580                         { VK_FORMAT_R5G6B5_UNORM_PACK16,        VK_COLOR_SPACE_SRGB_NONLINEAR_KHR       }
 581                 };
 582
 583                 requiredFormats         = &s_androidFormats[0];
 584                 numRequiredFormats      = DE_LENGTH_OF_ARRAY(s_androidFormats);
 585         }
 586
 587         for (size_t ndx = 0; ndx < numRequiredFormats; ++ndx)
 588         {
 589                 const VkSurfaceFormatKHR&       requiredFormat  = requiredFormats[ndx];
 590
 591                 if (!de::contains(formats.begin(), formats.end(), requiredFormat))
 592                         results.fail(de::toString(requiredFormat) + " not supported");
 593         }
 594
 595         // Check that there are no duplicates
 596         for (size_t ndx = 1; ndx < formats.size(); ++ndx)
 597         {
 598                 if (de::contains(formats.begin(), formats.begin() + ndx, formats[ndx]))
 599                         results.fail("Found duplicate entry " + de::toString(formats[ndx]));
 600         }
 601 }
 602
 603 tcu::TestStatus querySurfaceFormatsTest (Context& context, Type wsiType)
 604 {
 605         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
 606         tcu::ResultCollector                    results                 (log);
 607
 608         const InstanceHelper                    instHelper              (context, wsiType);
 609         const NativeObjects                             native                  (context, instHelper.supportedExtensions, wsiType);
 610         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 611         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 612
 613         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 614         {
 615                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 616                 {
 617                         deUint32        numFormats = 0;
 618
 619                         VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormatsKHR(physicalDevices[deviceNdx], *surface, &numFormats, DE_NULL));
 620
 621                         std::vector<VkSurfaceFormatKHR> formats (numFormats + 1);
 622
 623                         if (numFormats > 0)
 624                         {
 625                                 const deUint32 numFormatsOrig = numFormats;
 626
 627                                 // check if below call properly overwrites formats count
 628                                 numFormats++;
 629
 630                                 VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormatsKHR(physicalDevices[deviceNdx], *surface, &numFormats, &formats[0]));
 631
 632                                 if (numFormats != numFormatsOrig)
 633                                         results.fail("Format count changed between calls");
 634                         }
 635
 636                         formats.pop_back();
 637
 638                         log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(formats.begin(), formats.end()) << TestLog::EndMessage;
 639
 640                         validateSurfaceFormats(results, wsiType, formats);
 641                         CheckPhysicalDeviceSurfaceFormatsIncompleteResult()(results, instHelper.vki, physicalDevices[deviceNdx], *surface, formats.size());
 642                 }
 643                 // else skip query as surface is not supported by the device
 644         }
 645
 646         return tcu::TestStatus(results.getResult(), results.getMessage());
 647 }
 648
 649 tcu::TestStatus querySurfaceFormats2Test (Context& context, Type wsiType)
 650 {
 651         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
 652         tcu::ResultCollector                    results                 (log);
 653
 654         const InstanceHelper                    instHelper              (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
 655         const NativeObjects                             native                  (context, instHelper.supportedExtensions, wsiType);
 656         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 657         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 658
 659         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 660         {
 661                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 662                 {
 663                         const vector<VkSurfaceFormatKHR>                refFormats      = getPhysicalDeviceSurfaceFormats(instHelper.vki,
 664                                                                                                                                                                                                   physicalDevices[deviceNdx],
 665                                                                                                                                                                                                   *surface);
 666                         const VkPhysicalDeviceSurfaceInfo2KHR   surfaceInfo     =
 667                         {
 668                                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
 669                                 DE_NULL,
 670                                 *surface
 671                         };
 672                         deUint32                                                                numFormats      = 0;
 673
 674                         VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, DE_NULL));
 675
 676                         if ((size_t)numFormats != refFormats.size())
 677                                 results.fail("vkGetPhysicalDeviceSurfaceFormats2KHR() returned different number of formats");
 678
 679                         if (numFormats > 0)
 680                         {
 681                                 vector<VkSurfaceFormat2KHR>     formats (numFormats + 1);
 682
 683                                 for (size_t ndx = 0; ndx < formats.size(); ++ndx)
 684                                 {
 685                                         formats[ndx].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
 686                                         formats[ndx].pNext = DE_NULL;
 687                                 }
 688
 689                                 const deUint32 numFormatsOrig = numFormats;
 690
 691                                 // check if below call properly overwrites formats count
 692                                 numFormats++;
 693
 694                                 VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, &formats[0]));
 695
 696                                 if ((size_t)numFormats != numFormatsOrig)
 697                                         results.fail("Format count changed between calls");
 698
 699                                 formats.pop_back();
 700
 701                                 {
 702                                         vector<VkSurfaceFormatKHR>      extFormats      (formats.size());
 703
 704                                         for (size_t ndx = 0; ndx < formats.size(); ++ndx)
 705                                         {
 706                                                 results.check(formats[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
 707                                                                           formats[ndx].pNext == DE_NULL,
 708                                                                           "sType/pNext modified");
 709                                                 extFormats[ndx] = formats[ndx].surfaceFormat;
 710                                         }
 711
 712                                         for (size_t ndx = 0; ndx < refFormats.size(); ++ndx)
 713                                         {
 714                                                 if (!de::contains(extFormats.begin(), extFormats.end(), refFormats[ndx]))
 715                                                         results.fail(de::toString(refFormats[ndx]) + " missing from extended query");
 716                                         }
 717                                 }
 718
 719                                 // Check VK_INCOMPLETE
 720                                 {
 721                                         vector<VkSurfaceFormat2KHR>     formatsClone    (formats);
 722                                         deUint32                                        numToSupply             = numFormats/2;
 723                                         VkResult                                        queryResult;
 724
 725                                         ValidateQueryBits::fillBits(formatsClone.begin() + numToSupply, formatsClone.end());
 726
 727                                         queryResult = instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numToSupply, &formatsClone[0]);
 728
 729                                         results.check(queryResult == VK_INCOMPLETE, "Expected VK_INCOMPLETE");
 730                                         results.check(ValidateQueryBits::checkBits(formatsClone.begin() + numToSupply, formatsClone.end()),
 731                                                                   "Driver wrote past last element");
 732
 733                                         for (size_t ndx = 0; ndx < (size_t)numToSupply; ++ndx)
 734                                         {
 735                                                 results.check(formatsClone[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
 736                                                                           formatsClone[ndx].pNext == DE_NULL &&
 737                                                                           formatsClone[ndx].surfaceFormat == formats[ndx].surfaceFormat,
 738                                                                           "Returned element " + de::toString(ndx) + " is different");
 739                                         }
 740                                 }
 741                         }
 742                 }
 743                 // else skip query as surface is not supported by the device
 744         }
 745
 746         return tcu::TestStatus(results.getResult(), results.getMessage());
 747 }
 748
 749 void validateSurfacePresentModes (tcu::ResultCollector& results, Type wsiType, const vector<VkPresentModeKHR>& modes)
 750 {
 751         results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_FIFO_KHR),
 752                                   "VK_PRESENT_MODE_FIFO_KHR is not supported");
 753
 754         if (wsiType == TYPE_ANDROID)
 755                 results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_MAILBOX_KHR),
 756                                           "VK_PRESENT_MODE_MAILBOX_KHR is not supported");
 757 }
 758
 759 tcu::TestStatus querySurfacePresentModesTest (Context& context, Type wsiType)
 760 {
 761         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
 762         tcu::ResultCollector                    results                 (log);
 763
 764         const InstanceHelper                    instHelper              (context, wsiType);
 765         const NativeObjects                             native                  (context, instHelper.supportedExtensions, wsiType);
 766         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 767         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 768
 769         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 770         {
 771                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 772                 {
 773                         deUint32        numModes = 0;
 774
 775                         VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], *surface, &numModes, DE_NULL));
 776
 777                         vector<VkPresentModeKHR>        modes   (numModes + 1);
 778
 779                         if (numModes > 0)
 780                         {
 781                                 const deUint32 numModesOrig = numModes;
 782
 783                                 // check if below call properly overwrites mode count
 784                                 numModes++;
 785
 786                                 VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], *surface, &numModes, &modes[0]));
 787
 788                                 if ((size_t)numModes != numModesOrig)
 789                                         TCU_FAIL("Mode count changed between calls");
 790                         }
 791
 792                         modes.pop_back();
 793
 794                         log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(modes.begin(), modes.end()) << TestLog::EndMessage;
 795
 796                         validateSurfacePresentModes(results, wsiType, modes);
 797                         CheckPhysicalDeviceSurfacePresentModesIncompleteResult()(results, instHelper.vki, physicalDevices[deviceNdx], *surface, modes.size());
 798                 }
 799                 // else skip query as surface is not supported by the device
 800         }
 801
 802         return tcu::TestStatus(results.getResult(), results.getMessage());
 803 }
 804
 805 tcu::TestStatus queryDevGroupSurfacePresentCapabilitiesTest (Context& context, Type wsiType)
 806 {
 807         tcu::TestLog&                                                                   log                                             = context.getTestContext().getLog();
 808         const InstanceHelper                                                    instHelper                              (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
 809         const float                                                                             queuePriority                   = 1.0f;
 810         const tcu::CommandLine&                                                 cmdLine                                 = context.getTestContext().getCommandLine();
 811         const deUint32                                                                  devGroupIdx                             = cmdLine.getVKDeviceGroupId() - 1;
 812         const deUint32                                                                  deviceIdx                               = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
 813         const VkDeviceGroupPresentModeFlagsKHR                  requiredFlag                    = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
 814         const VkDeviceGroupPresentModeFlagsKHR                  maxValidFlag                    = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
 815                                                                                                                                                                 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
 816         deUint8                                                                                 buffer                                  [sizeof(VkDeviceGroupPresentCapabilitiesKHR) + GUARD_SIZE];
 817         deUint32                                                                                queueFamilyIndex                = 0;
 818         VkDeviceGroupPresentCapabilitiesKHR*                    presentCapabilities;
 819         VkPhysicalDevice                                                                physicalDevice                  = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
 820         const Extensions&                                                               supportedExtensions             = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
 821         std::vector<const char*>                                                deviceExtensions;
 822
 823         if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
 824                 deviceExtensions.push_back("VK_KHR_device_group");
 825         deviceExtensions.push_back("VK_KHR_swapchain");
 826
 827         for (int ndx = 0; ndx < int(deviceExtensions.size()); ++ndx)
 828         {
 829                 if (!isExtensionSupported(supportedExtensions, RequiredExtension(deviceExtensions[ndx])))
 830                         TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
 831         }
 832
 833         const vector<VkPhysicalDeviceGroupProperties>   deviceGroupProps                = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
 834
 835         const std::vector<VkQueueFamilyProperties>              queueProps                              = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
 836         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 837         {
 838                 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
 839                         queueFamilyIndex = (deUint32)queueNdx;
 840         }
 841         const VkDeviceQueueCreateInfo                                   deviceQueueCreateInfo   =
 842         {
 843                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                             //type
 844                 DE_NULL,                                                                                                //pNext
 845                 (VkDeviceQueueCreateFlags)0u,                                                   //flags
 846                 queueFamilyIndex,                                                                               //queueFamilyIndex;
 847                 1u,                                                                                                             //queueCount;
 848                 &queuePriority,                                                                                 //pQueuePriorities;
 849         };
 850         const VkDeviceGroupDeviceCreateInfo                             deviceGroupInfo                 =
 851         {
 852                 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,  //stype
 853                 DE_NULL,                                                                                                //pNext
 854                 deviceGroupProps[devGroupIdx].physicalDeviceCount,              //physicalDeviceCount
 855                 deviceGroupProps[devGroupIdx].physicalDevices                   //physicalDevices
 856         };
 857         const VkDeviceCreateInfo                                                deviceCreateInfo                =
 858         {
 859                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                   //sType;
 860                 &deviceGroupInfo,                                                                                               //pNext;
 861                 (VkDeviceCreateFlags)0u,                                                                                //flags
 862                 1,                                                                                                                              //queueRecordCount;
 863                 &deviceQueueCreateInfo,                                                                                 //pRequestedQueues;
 864                 0,                                                                                                                              //layerCount;
 865                 DE_NULL,                                                                                                                //ppEnabledLayerNames;
 866                 deUint32(deviceExtensions.size()),                                                              //enabledExtensionCount;
 867                 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]),    //ppEnabledExtensionNames;
 868                 DE_NULL,                                                                                                                //pEnabledFeatures;
 869         };
 870         Move<VkDevice>          deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
 871         const DeviceDriver      vk      (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
 872
 873
 874         presentCapabilities = reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(buffer);
 875         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
 876         presentCapabilities->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
 877         presentCapabilities->pNext = DE_NULL;
 878         VK_CHECK(vk.getDeviceGroupPresentCapabilitiesKHR(deviceGroup.get(), presentCapabilities));
 879
 880         // Guard check
 881         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
 882         {
 883                 if (buffer[ndx + sizeof(VkDeviceGroupPresentCapabilitiesKHR)] != GUARD_VALUE)
 884                 {
 885                         log << TestLog::Message << "deviceGroupPresentCapabilities - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
 886                         return tcu::TestStatus::fail("deviceGroupPresentCapabilities buffer overflow");
 887                 }
 888         }
 889
 890         // Check each physical device can present on itself
 891         for (size_t physDevIdx = 0; physDevIdx < VK_MAX_DEVICE_GROUP_SIZE_KHR; physDevIdx++)
 892         {
 893                 if (presentCapabilities->presentMask[physDevIdx])
 894                         if (!((1 << physDevIdx) & (presentCapabilities->presentMask[physDevIdx])))
 895                                 return tcu::TestStatus::fail("deviceGroupPresentCapabilities, device can not present on itself, invalid present mask");
 896         }
 897
 898         // Check if flags are valid
 899         if ((!(presentCapabilities->modes & requiredFlag)) ||
 900                 presentCapabilities->modes > maxValidFlag)
 901                 return tcu::TestStatus::fail("deviceGroupPresentCapabilities flag not valid");
 902
 903         return tcu::TestStatus::pass("Querying deviceGroup present capabilities succeeded");
 904 }
 905
 906 tcu::TestStatus queryDevGroupSurfacePresentModesTest (Context& context, Type wsiType)
 907 {
 908         tcu::TestLog&                                                   log                                     = context.getTestContext().getLog();
 909         tcu::ResultCollector                                    results                         (log);
 910         const InstanceHelper                                    instHelper                      (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
 911         const NativeObjects                                             native                          (context, instHelper.supportedExtensions, wsiType);
 912         const Unique<VkSurfaceKHR>                              surface                         (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 913         const float                                                             queuePriority           = 1.0f;
 914         const tcu::CommandLine&                                 cmdLine                         = context.getTestContext().getCommandLine();
 915         const deUint32                                                  devGroupIdx                     = cmdLine.getVKDeviceGroupId() - 1;
 916         const deUint32                                                  deviceIdx                       = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
 917         const VkDeviceGroupPresentModeFlagsKHR  requiredFlag            = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
 918         const VkDeviceGroupPresentModeFlagsKHR  maxValidFlag            = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
 919                                                                                                                                         VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
 920         VkResult                                                                result                          = VK_SUCCESS;
 921         deUint8                                                                 buffer                          [sizeof(VkDeviceGroupPresentModeFlagsKHR) + GUARD_SIZE];
 922         deUint32                                                                rectCount                       = 0;
 923         deUint32                                                                incompleteRectCount     = 0;
 924         deUint32                                                                queueFamilyIndex        = 0;
 925         VkRect2D*                                                               presentRectangles;
 926         VkDeviceGroupPresentModeFlagsKHR*               presentModeFlags;
 927         vector<deUint8>                                                 rectanglesBuffer;
 928         VkPhysicalDevice                                                physicalDevice          = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
 929         const Extensions&                                               supportedExtensions     = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
 930         std::vector<const char*>                                deviceExtensions;
 931
 932         if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
 933                 deviceExtensions.push_back("VK_KHR_device_group");
 934         deviceExtensions.push_back("VK_KHR_swapchain");
 935
 936         for (int ndx = 0; ndx < int(deviceExtensions.size()); ++ndx)
 937         {
 938                 if (!isExtensionSupported(supportedExtensions, RequiredExtension(deviceExtensions[ndx])))
 939                         TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
 940         }
 941
 942         const vector<VkPhysicalDeviceGroupProperties>   deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
 943         const std::vector<VkQueueFamilyProperties>      queueProps              = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
 944         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 945         {
 946                 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
 947                         queueFamilyIndex = (deUint32)queueNdx;
 948         }
 949         const VkDeviceQueueCreateInfo                   deviceQueueCreateInfo =
 950         {
 951                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                                     //type
 952                 DE_NULL,                                                                                                        //pNext
 953                 (VkDeviceQueueCreateFlags)0u,                                                           //flags
 954                 queueFamilyIndex,                                                                                       //queueFamilyIndex;
 955                 1u,                                                                                                                     //queueCount;
 956                 &queuePriority,                                                                                         //pQueuePriorities;
 957         };
 958         const VkDeviceGroupDeviceCreateInfo                     deviceGroupInfo =
 959         {
 960                 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,  //stype
 961                 DE_NULL,                                                                                                //pNext
 962                 deviceGroupProps[devGroupIdx].physicalDeviceCount,              //physicalDeviceCount
 963                 deviceGroupProps[devGroupIdx].physicalDevices                   //physicalDevices
 964         };
 965         const VkDeviceCreateInfo                                                deviceCreateInfo =
 966         {
 967                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                   //sType;
 968                 &deviceGroupInfo,                                                                                               //pNext;
 969                 (VkDeviceCreateFlags)0u,                                                                                //flags
 970                 1,                                                                                                                              //queueRecordCount;
 971                 &deviceQueueCreateInfo,                                                                                 //pRequestedQueues;
 972                 0,                                                                                                                              //layerCount;
 973                 DE_NULL,                                                                                                                //ppEnabledLayerNames;
 974                 deUint32(deviceExtensions.size()),                                                              //enabledExtensionCount;
 975                 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]),    //ppEnabledExtensionNames;
 976                 DE_NULL,                                                                                                                //pEnabledFeatures;
 977         };
 978
 979         Move<VkDevice>          deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
 980         const DeviceDriver      vk      (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
 981         presentModeFlags = reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>(buffer);
 982         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
 983
 984         VK_CHECK(vk.getDeviceGroupSurfacePresentModesKHR(deviceGroup.get(), *surface, presentModeFlags));
 985
 986         // Guard check
 987         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
 988         {
 989                 if (buffer[ndx + sizeof(VkDeviceGroupPresentModeFlagsKHR)] != GUARD_VALUE)
 990                 {
 991                         log << TestLog::Message << "queryDevGroupSurfacePresentModesTest - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
 992                         return tcu::TestStatus::fail("queryDevGroupSurfacePresentModesTest buffer overflow");
 993                 }
 994         }
 995
 996         // Check if flags are valid
 997         if ((!(*presentModeFlags & requiredFlag)) ||
 998                 *presentModeFlags > maxValidFlag)
 999                 return tcu::TestStatus::fail("queryDevGroupSurfacePresentModesTest flag not valid");
1000
1001         // Check presentation rectangles
1002         if (*presentModeFlags == VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR)
1003         {
1004                 for (size_t physDevIdx = 0; physDevIdx < deviceGroupProps[devGroupIdx].physicalDeviceCount; physDevIdx++)
1005                 {
1006                         VK_CHECK(instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &rectCount, DE_NULL));
1007                         rectanglesBuffer.resize(sizeof(VkRect2D) * rectCount + GUARD_SIZE);
1008                         presentRectangles = reinterpret_cast<VkRect2D*>(rectanglesBuffer.data());
1009                         deMemset(rectanglesBuffer.data(), GUARD_VALUE, rectanglesBuffer.size());
1010
1011                         VK_CHECK(instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &rectCount, presentRectangles));
1012
1013                         // Guard check
1014                         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
1015                         {
1016                                 if (rectanglesBuffer[ndx + sizeof(VkRect2D) * rectCount] != GUARD_VALUE)
1017                                 {
1018                                         log << TestLog::Message << "getPhysicalDevicePresentRectanglesKHR - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
1019                                         return tcu::TestStatus::fail("getPhysicalDevicePresentRectanglesKHR buffer overflow");
1020                                 }
1021                         }
1022
1023                         // Check rectangles do not overlap
1024                         for (size_t rectIdx1 = 0; rectIdx1 < rectCount; rectIdx1++)
1025                         {
1026                                 for (size_t rectIdx2 = 0; rectIdx2 < rectCount; rectIdx2++)
1027                                 {
1028                                         if (rectIdx1 != rectIdx2)
1029                                         {
1030                                                 deUint32 rectATop               = presentRectangles[rectIdx1].offset.y;
1031                                                 deUint32 rectALeft              = presentRectangles[rectIdx1].offset.x;
1032                                                 deUint32 rectABottom    = presentRectangles[rectIdx1].offset.y + presentRectangles[rectIdx1].extent.height;
1033                                                 deUint32 rectARight             = presentRectangles[rectIdx1].offset.x + presentRectangles[rectIdx1].extent.width;
1034
1035                                                 deUint32 rectBTop               = presentRectangles[rectIdx2].offset.y;
1036                                                 deUint32 rectBLeft              = presentRectangles[rectIdx2].offset.x;
1037                                                 deUint32 rectBBottom    = presentRectangles[rectIdx2].offset.y + presentRectangles[rectIdx2].extent.height;
1038                                                 deUint32 rectBRight             = presentRectangles[rectIdx2].offset.x + presentRectangles[rectIdx2].extent.width;
1039
1040                                                 if (rectALeft < rectBRight && rectARight > rectBLeft &&
1041                                                         rectATop < rectBBottom && rectABottom > rectBTop)
1042                                                         return tcu::TestStatus::fail("getPhysicalDevicePresentRectanglesKHR rectangles overlap");
1043                                         }
1044                                 }
1045                         }
1046
1047                         // Check incomplete
1048                         incompleteRectCount = rectCount / 2;
1049                         result = instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &incompleteRectCount, presentRectangles);
1050                         results.check(result == VK_INCOMPLETE, "Expected VK_INCOMPLETE");
1051                 }
1052         }
1053         return tcu::TestStatus(results.getResult(), results.getMessage());
1054 }
1055
1056 tcu::TestStatus createSurfaceInitialSizeTest (Context& context, Type wsiType)
1057 {
1058         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
1059         tcu::ResultCollector                    results                 (log);
1060
1061         const InstanceHelper                    instHelper              (context, wsiType);
1062
1063         const UniquePtr<Display>                nativeDisplay   (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(),
1064                                                                                                                                    instHelper.supportedExtensions,
1065                                                                                                                                    wsiType));
1066
1067         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
1068         const UVec2                                             sizes[]                 =
1069         {
1070                 UVec2(64, 64),
1071                 UVec2(124, 119),
1072                 UVec2(256, 512)
1073         };
1074
1075         DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE);
1076
1077         for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
1078         {
1079                 const UVec2&                            testSize                = sizes[sizeNdx];
1080                 const UniquePtr<Window>         nativeWindow    (createWindow(*nativeDisplay, tcu::just(testSize)));
1081                 const Unique<VkSurfaceKHR>      surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
1082
1083                 for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
1084                 {
1085                         if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
1086                         {
1087                                 const VkSurfaceCapabilitiesKHR  capabilities    = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface);
1088
1089                                 // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform
1090                                 results.check(capabilities.currentExtent.width == testSize.x() &&
1091                                                                 capabilities.currentExtent.height == testSize.y(),
1092                                                                 "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize));
1093                         }
1094                 }
1095         }
1096
1097         return tcu::TestStatus(results.getResult(), results.getMessage());
1098 }
1099
1100 tcu::TestStatus resizeSurfaceTest (Context& context, Type wsiType)
1101 {
1102         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
1103         tcu::ResultCollector                    results                 (log);
1104
1105         const InstanceHelper                    instHelper              (context, wsiType);
1106
1107         const UniquePtr<Display>                nativeDisplay   (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(),
1108                                                                                                                                    instHelper.supportedExtensions,
1109                                                                                                                                    wsiType));
1110         UniquePtr<Window>                               nativeWindow    (createWindow(*nativeDisplay, tcu::nothing<UVec2>()));
1111
1112         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
1113         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
1114
1115         const UVec2                                             sizes[]                 =
1116         {
1117                 UVec2(64, 64),
1118                 UVec2(124, 119),
1119                 UVec2(256, 512)
1120         };
1121
1122         DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_RESIZE_WINDOW);
1123
1124         for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
1125         {
1126                 const UVec2             testSize        = sizes[sizeNdx];
1127
1128                 try
1129                 {
1130                         nativeWindow->resize(testSize);
1131                 }
1132                 catch (const tcu::Exception& e)
1133                 {
1134                         // Make sure all exception types result in a test failure
1135                         results.fail(e.getMessage());
1136                 }
1137
1138                 for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
1139                 {
1140                         if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
1141                         {
1142                                 const VkSurfaceCapabilitiesKHR  capabilities    = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface);
1143
1144                                 // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform
1145                                 results.check(capabilities.currentExtent.width == testSize.x() &&
1146                                                                 capabilities.currentExtent.height == testSize.y(),
1147                                                                 "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize));
1148                         }
1149                 }
1150         }
1151
1152         return tcu::TestStatus(results.getResult(), results.getMessage());
1153 }
1154
1155 tcu::TestStatus destroyNullHandleSurfaceTest (Context& context, Type wsiType)
1156 {
1157         const InstanceHelper    instHelper      (context, wsiType);
1158         const VkSurfaceKHR              nullHandle      = DE_NULL;
1159
1160         // Default allocator
1161         instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, DE_NULL);
1162
1163         // Custom allocator
1164         {
1165                 AllocationCallbackRecorder      recordingAllocator      (getSystemAllocator(), 1u);
1166
1167                 instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, recordingAllocator.getCallbacks());
1168
1169                 if (recordingAllocator.getNumRecords() != 0u)
1170                         return tcu::TestStatus::fail("Implementation allocated/freed the memory");
1171         }
1172
1173         return tcu::TestStatus::pass("Destroying a VK_NULL_HANDLE surface has no effect");
1174 }
1175
1176 } // anonymous
1177
1178 void createSurfaceTests (tcu::TestCaseGroup* testGroup, vk::wsi::Type wsiType)
1179 {
1180         const PlatformProperties&       platformProperties      = getPlatformProperties(wsiType);
1181
1182         addFunctionCase(testGroup, "create",                                                            "Create surface",                                                                                       createSurfaceTest,                                                      wsiType);
1183         addFunctionCase(testGroup, "create_custom_allocator",                           "Create surface with custom allocator",                                         createSurfaceCustomAllocatorTest,                       wsiType);
1184         addFunctionCase(testGroup, "create_simulate_oom",                                       "Create surface with simulating OOM",                                           createSurfaceSimulateOOMTest,                           wsiType);
1185         addFunctionCase(testGroup, "query_support",                                                     "Query surface support",                                                                        querySurfaceSupportTest,                                        wsiType);
1186         addFunctionCase(testGroup, "query_capabilities",                                        "Query surface capabilities",                                                           querySurfaceCapabilitiesTest,                           wsiType);
1187         addFunctionCase(testGroup, "query_capabilities2",                                       "Query extended surface capabilities",                                          querySurfaceCapabilities2Test,                          wsiType);
1188         addFunctionCase(testGroup, "query_formats",                                                     "Query surface formats",                                                                        querySurfaceFormatsTest,                                        wsiType);
1189         addFunctionCase(testGroup, "query_formats2",                                            "Query extended surface formats",                                                       querySurfaceFormats2Test,                                       wsiType);
1190         addFunctionCase(testGroup, "query_present_modes",                                       "Query surface present modes",                                                          querySurfacePresentModesTest,                           wsiType);
1191         addFunctionCase(testGroup, "query_devgroup_present_capabilities",       "Query surface present modes capabilities in device groups",queryDevGroupSurfacePresentCapabilitiesTest,wsiType);
1192         addFunctionCase(testGroup, "query_devgroup_present_modes",                      "Query surface present modes for device groups",                        queryDevGroupSurfacePresentModesTest,           wsiType);
1193         addFunctionCase(testGroup, "destroy_null_handle",                                       "Destroy VK_NULL_HANDLE surface",                                                       destroyNullHandleSurfaceTest,                           wsiType);
1194
1195         if ((platformProperties.features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE) != 0)
1196                 addFunctionCase(testGroup, "initial_size",      "Create surface with initial window size set",  createSurfaceInitialSizeTest,   wsiType);
1197
1198         if ((platformProperties.features & PlatformProperties::FEATURE_RESIZE_WINDOW) != 0)
1199                 addFunctionCase(testGroup, "resize",            "Resize window and surface",                                    resizeSurfaceTest,                              wsiType);
1200 }
1201
1202 } // wsi
1203 } // vkt