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                         const vector<VkSurfaceFormatKHR>        formats = getPhysicalDeviceSurfaceFormats(instHelper.vki,
 618                                                                                                                                                                                   physicalDevices[deviceNdx],
 619                                                                                                                                                                                   *surface);
 620
 621                         log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(formats.begin(), formats.end()) << TestLog::EndMessage;
 622
 623                         validateSurfaceFormats(results, wsiType, formats);
 624                         CheckPhysicalDeviceSurfaceFormatsIncompleteResult()(results, instHelper.vki, physicalDevices[deviceNdx], *surface, formats.size());
 625                 }
 626                 // else skip query as surface is not supported by the device
 627         }
 628
 629         return tcu::TestStatus(results.getResult(), results.getMessage());
 630 }
 631
 632 tcu::TestStatus querySurfaceFormats2Test (Context& context, Type wsiType)
 633 {
 634         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
 635         tcu::ResultCollector                    results                 (log);
 636
 637         const InstanceHelper                    instHelper              (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
 638         const NativeObjects                             native                  (context, instHelper.supportedExtensions, wsiType);
 639         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 640         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 641
 642         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 643         {
 644                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 645                 {
 646                         const vector<VkSurfaceFormatKHR>                refFormats      = getPhysicalDeviceSurfaceFormats(instHelper.vki,
 647                                                                                                                                                                                                   physicalDevices[deviceNdx],
 648                                                                                                                                                                                                   *surface);
 649                         const VkPhysicalDeviceSurfaceInfo2KHR   surfaceInfo     =
 650                         {
 651                                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
 652                                 DE_NULL,
 653                                 *surface
 654                         };
 655                         deUint32                                                                numFormats      = 0;
 656
 657                         VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, DE_NULL));
 658
 659                         if ((size_t)numFormats != refFormats.size())
 660                                 results.fail("vkGetPhysicalDeviceSurfaceFormats2KHR() returned different number of formats");
 661
 662                         if (numFormats > 0)
 663                         {
 664                                 vector<VkSurfaceFormat2KHR>     formats (numFormats);
 665
 666                                 for (size_t ndx = 0; ndx < formats.size(); ++ndx)
 667                                 {
 668                                         formats[ndx].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
 669                                         formats[ndx].pNext = DE_NULL;
 670                                 }
 671
 672                                 VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, &formats[0]));
 673
 674                                 if ((size_t)numFormats != formats.size())
 675                                         results.fail("Format count changed between calls");
 676
 677                                 {
 678                                         vector<VkSurfaceFormatKHR>      extFormats      (formats.size());
 679
 680                                         for (size_t ndx = 0; ndx < formats.size(); ++ndx)
 681                                         {
 682                                                 results.check(formats[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
 683                                                                           formats[ndx].pNext == DE_NULL,
 684                                                                           "sType/pNext modified");
 685                                                 extFormats[ndx] = formats[ndx].surfaceFormat;
 686                                         }
 687
 688                                         for (size_t ndx = 0; ndx < refFormats.size(); ++ndx)
 689                                         {
 690                                                 if (!de::contains(extFormats.begin(), extFormats.end(), refFormats[ndx]))
 691                                                         results.fail(de::toString(refFormats[ndx]) + " missing from extended query");
 692                                         }
 693                                 }
 694
 695                                 // Check VK_INCOMPLETE
 696                                 {
 697                                         vector<VkSurfaceFormat2KHR>     formatsClone    (formats);
 698                                         deUint32                                        numToSupply             = numFormats/2;
 699                                         VkResult                                        queryResult;
 700
 701                                         ValidateQueryBits::fillBits(formatsClone.begin() + numToSupply, formatsClone.end());
 702
 703                                         queryResult = instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numToSupply, &formatsClone[0]);
 704
 705                                         results.check(queryResult == VK_INCOMPLETE, "Expected VK_INCOMPLETE");
 706                                         results.check(ValidateQueryBits::checkBits(formatsClone.begin() + numToSupply, formatsClone.end()),
 707                                                                   "Driver wrote past last element");
 708
 709                                         for (size_t ndx = 0; ndx < (size_t)numToSupply; ++ndx)
 710                                         {
 711                                                 results.check(formatsClone[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
 712                                                                           formatsClone[ndx].pNext == DE_NULL &&
 713                                                                           formatsClone[ndx].surfaceFormat == formats[ndx].surfaceFormat,
 714                                                                           "Returned element " + de::toString(ndx) + " is different");
 715                                         }
 716                                 }
 717                         }
 718                 }
 719                 // else skip query as surface is not supported by the device
 720         }
 721
 722         return tcu::TestStatus(results.getResult(), results.getMessage());
 723 }
 724
 725 void validateSurfacePresentModes (tcu::ResultCollector& results, Type wsiType, const vector<VkPresentModeKHR>& modes)
 726 {
 727         results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_FIFO_KHR),
 728                                   "VK_PRESENT_MODE_FIFO_KHR is not supported");
 729
 730         if (wsiType == TYPE_ANDROID)
 731                 results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_MAILBOX_KHR),
 732                                           "VK_PRESENT_MODE_MAILBOX_KHR is not supported");
 733 }
 734
 735 tcu::TestStatus querySurfacePresentModesTest (Context& context, Type wsiType)
 736 {
 737         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
 738         tcu::ResultCollector                    results                 (log);
 739
 740         const InstanceHelper                    instHelper              (context, wsiType);
 741         const NativeObjects                             native                  (context, instHelper.supportedExtensions, wsiType);
 742         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 743         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
 744
 745         for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
 746         {
 747                 if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
 748                 {
 749                         const vector<VkPresentModeKHR>  modes   = getPhysicalDeviceSurfacePresentModes(instHelper.vki, physicalDevices[deviceNdx], *surface);
 750
 751                         log << TestLog::Message << "Device " << deviceNdx << ": " << tcu::formatArray(modes.begin(), modes.end()) << TestLog::EndMessage;
 752
 753                         validateSurfacePresentModes(results, wsiType, modes);
 754                         CheckPhysicalDeviceSurfacePresentModesIncompleteResult()(results, instHelper.vki, physicalDevices[deviceNdx], *surface, modes.size());
 755                 }
 756                 // else skip query as surface is not supported by the device
 757         }
 758
 759         return tcu::TestStatus(results.getResult(), results.getMessage());
 760 }
 761
 762 tcu::TestStatus queryDevGroupSurfacePresentCapabilitiesTest (Context& context, Type wsiType)
 763 {
 764         tcu::TestLog&                                                                   log                                             = context.getTestContext().getLog();
 765         const InstanceHelper                                                    instHelper                              (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
 766         const float                                                                             queuePriority                   = 1.0f;
 767         const tcu::CommandLine&                                                 cmdLine                                 = context.getTestContext().getCommandLine();
 768         const deUint32                                                                  devGroupIdx                             = cmdLine.getVKDeviceGroupId() - 1;
 769         const deUint32                                                                  deviceIdx                               = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
 770         const VkDeviceGroupPresentModeFlagsKHR                  requiredFlag                    = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
 771         const VkDeviceGroupPresentModeFlagsKHR                  maxValidFlag                    = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
 772                                                                                                                                                                 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
 773         deUint8                                                                                 buffer                                  [sizeof(VkDeviceGroupPresentCapabilitiesKHR) + GUARD_SIZE];
 774         deUint32                                                                                queueFamilyIndex                = 0;
 775         VkDeviceGroupPresentCapabilitiesKHR*                    presentCapabilities;
 776         VkPhysicalDevice                                                                physicalDevice                  = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
 777         const Extensions&                                                               supportedExtensions             = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
 778         std::vector<const char*>                                                deviceExtensions;
 779
 780         if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
 781                 deviceExtensions.push_back("VK_KHR_device_group");
 782         deviceExtensions.push_back("VK_KHR_swapchain");
 783
 784         for (int ndx = 0; ndx < int(deviceExtensions.size()); ++ndx)
 785         {
 786                 if (!isExtensionSupported(supportedExtensions, RequiredExtension(deviceExtensions[ndx])))
 787                         TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
 788         }
 789
 790         const vector<VkPhysicalDeviceGroupProperties>   deviceGroupProps                = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
 791
 792         const std::vector<VkQueueFamilyProperties>              queueProps                              = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
 793         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 794         {
 795                 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
 796                         queueFamilyIndex = (deUint32)queueNdx;
 797         }
 798         const VkDeviceQueueCreateInfo                                   deviceQueueCreateInfo   =
 799         {
 800                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                             //type
 801                 DE_NULL,                                                                                                //pNext
 802                 (VkDeviceQueueCreateFlags)0u,                                                   //flags
 803                 queueFamilyIndex,                                                                               //queueFamilyIndex;
 804                 1u,                                                                                                             //queueCount;
 805                 &queuePriority,                                                                                 //pQueuePriorities;
 806         };
 807         const VkDeviceGroupDeviceCreateInfo                             deviceGroupInfo                 =
 808         {
 809                 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,  //stype
 810                 DE_NULL,                                                                                                //pNext
 811                 deviceGroupProps[devGroupIdx].physicalDeviceCount,              //physicalDeviceCount
 812                 deviceGroupProps[devGroupIdx].physicalDevices                   //physicalDevices
 813         };
 814         const VkDeviceCreateInfo                                                deviceCreateInfo                =
 815         {
 816                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                   //sType;
 817                 &deviceGroupInfo,                                                                                               //pNext;
 818                 (VkDeviceCreateFlags)0u,                                                                                //flags
 819                 1,                                                                                                                              //queueRecordCount;
 820                 &deviceQueueCreateInfo,                                                                                 //pRequestedQueues;
 821                 0,                                                                                                                              //layerCount;
 822                 DE_NULL,                                                                                                                //ppEnabledLayerNames;
 823                 deUint32(deviceExtensions.size()),                                                              //enabledExtensionCount;
 824                 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]),    //ppEnabledExtensionNames;
 825                 DE_NULL,                                                                                                                //pEnabledFeatures;
 826         };
 827         Move<VkDevice>          deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
 828         const DeviceDriver      vk      (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
 829
 830
 831         presentCapabilities = reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(buffer);
 832         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
 833         presentCapabilities->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
 834         presentCapabilities->pNext = DE_NULL;
 835         VK_CHECK(vk.getDeviceGroupPresentCapabilitiesKHR(deviceGroup.get(), presentCapabilities));
 836
 837         // Guard check
 838         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
 839         {
 840                 if (buffer[ndx + sizeof(VkDeviceGroupPresentCapabilitiesKHR)] != GUARD_VALUE)
 841                 {
 842                         log << TestLog::Message << "deviceGroupPresentCapabilities - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
 843                         return tcu::TestStatus::fail("deviceGroupPresentCapabilities buffer overflow");
 844                 }
 845         }
 846
 847         // Check each physical device can present on itself
 848         for (size_t physDevIdx = 0; physDevIdx < VK_MAX_DEVICE_GROUP_SIZE_KHR; physDevIdx++)
 849         {
 850                 if (presentCapabilities->presentMask[physDevIdx])
 851                         if (!((1 << physDevIdx) & (presentCapabilities->presentMask[physDevIdx])))
 852                                 return tcu::TestStatus::fail("deviceGroupPresentCapabilities, device can not present on itself, invalid present mask");
 853         }
 854
 855         // Check if flags are valid
 856         if ((!(presentCapabilities->modes & requiredFlag)) ||
 857                 presentCapabilities->modes > maxValidFlag)
 858                 return tcu::TestStatus::fail("deviceGroupPresentCapabilities flag not valid");
 859
 860         return tcu::TestStatus::pass("Querying deviceGroup present capabilities succeeded");
 861 }
 862
 863 tcu::TestStatus queryDevGroupSurfacePresentModesTest (Context& context, Type wsiType)
 864 {
 865         tcu::TestLog&                                                   log                                     = context.getTestContext().getLog();
 866         tcu::ResultCollector                                    results                         (log);
 867         const InstanceHelper                                    instHelper                      (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
 868         const NativeObjects                                             native                          (context, instHelper.supportedExtensions, wsiType);
 869         const Unique<VkSurfaceKHR>                              surface                         (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
 870         const float                                                             queuePriority           = 1.0f;
 871         const tcu::CommandLine&                                 cmdLine                         = context.getTestContext().getCommandLine();
 872         const deUint32                                                  devGroupIdx                     = cmdLine.getVKDeviceGroupId() - 1;
 873         const deUint32                                                  deviceIdx                       = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
 874         const VkDeviceGroupPresentModeFlagsKHR  requiredFlag            = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
 875         const VkDeviceGroupPresentModeFlagsKHR  maxValidFlag            = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
 876                                                                                                                                         VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
 877         VkResult                                                                result                          = VK_SUCCESS;
 878         deUint8                                                                 buffer                          [sizeof(VkDeviceGroupPresentModeFlagsKHR) + GUARD_SIZE];
 879         deUint32                                                                rectCount                       = 0;
 880         deUint32                                                                incompleteRectCount     = 0;
 881         deUint32                                                                queueFamilyIndex        = 0;
 882         VkRect2D*                                                               presentRectangles;
 883         VkDeviceGroupPresentModeFlagsKHR*               presentModeFlags;
 884         vector<deUint8>                                                 rectanglesBuffer;
 885         VkPhysicalDevice                                                physicalDevice          = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
 886         const Extensions&                                               supportedExtensions     = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
 887         std::vector<const char*>                                deviceExtensions;
 888
 889         if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
 890                 deviceExtensions.push_back("VK_KHR_device_group");
 891         deviceExtensions.push_back("VK_KHR_swapchain");
 892
 893         for (int ndx = 0; ndx < int(deviceExtensions.size()); ++ndx)
 894         {
 895                 if (!isExtensionSupported(supportedExtensions, RequiredExtension(deviceExtensions[ndx])))
 896                         TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
 897         }
 898
 899         const vector<VkPhysicalDeviceGroupProperties>   deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
 900         const std::vector<VkQueueFamilyProperties>      queueProps              = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
 901         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 902         {
 903                 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
 904                         queueFamilyIndex = (deUint32)queueNdx;
 905         }
 906         const VkDeviceQueueCreateInfo                   deviceQueueCreateInfo =
 907         {
 908                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                                     //type
 909                 DE_NULL,                                                                                                        //pNext
 910                 (VkDeviceQueueCreateFlags)0u,                                                           //flags
 911                 queueFamilyIndex,                                                                                       //queueFamilyIndex;
 912                 1u,                                                                                                                     //queueCount;
 913                 &queuePriority,                                                                                         //pQueuePriorities;
 914         };
 915         const VkDeviceGroupDeviceCreateInfo                     deviceGroupInfo =
 916         {
 917                 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,  //stype
 918                 DE_NULL,                                                                                                //pNext
 919                 deviceGroupProps[devGroupIdx].physicalDeviceCount,              //physicalDeviceCount
 920                 deviceGroupProps[devGroupIdx].physicalDevices                   //physicalDevices
 921         };
 922         const VkDeviceCreateInfo                                                deviceCreateInfo =
 923         {
 924                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                   //sType;
 925                 &deviceGroupInfo,                                                                                               //pNext;
 926                 (VkDeviceCreateFlags)0u,                                                                                //flags
 927                 1,                                                                                                                              //queueRecordCount;
 928                 &deviceQueueCreateInfo,                                                                                 //pRequestedQueues;
 929                 0,                                                                                                                              //layerCount;
 930                 DE_NULL,                                                                                                                //ppEnabledLayerNames;
 931                 deUint32(deviceExtensions.size()),                                                              //enabledExtensionCount;
 932                 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]),    //ppEnabledExtensionNames;
 933                 DE_NULL,                                                                                                                //pEnabledFeatures;
 934         };
 935
 936         Move<VkDevice>          deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
 937         const DeviceDriver      vk      (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
 938         presentModeFlags = reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>(buffer);
 939         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
 940
 941         VK_CHECK(vk.getDeviceGroupSurfacePresentModesKHR(deviceGroup.get(), *surface, presentModeFlags));
 942
 943         // Guard check
 944         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
 945         {
 946                 if (buffer[ndx + sizeof(VkDeviceGroupPresentModeFlagsKHR)] != GUARD_VALUE)
 947                 {
 948                         log << TestLog::Message << "queryDevGroupSurfacePresentModesTest - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
 949                         return tcu::TestStatus::fail("queryDevGroupSurfacePresentModesTest buffer overflow");
 950                 }
 951         }
 952
 953         // Check if flags are valid
 954         if ((!(*presentModeFlags & requiredFlag)) ||
 955                 *presentModeFlags > maxValidFlag)
 956                 return tcu::TestStatus::fail("queryDevGroupSurfacePresentModesTest flag not valid");
 957
 958         // Check presentation rectangles
 959         if (*presentModeFlags == VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR)
 960         {
 961                 for (size_t physDevIdx = 0; physDevIdx < deviceGroupProps[devGroupIdx].physicalDeviceCount; physDevIdx++)
 962                 {
 963                         VK_CHECK(instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &rectCount, DE_NULL));
 964                         rectanglesBuffer.resize(sizeof(VkRect2D) * rectCount + GUARD_SIZE);
 965                         presentRectangles = reinterpret_cast<VkRect2D*>(rectanglesBuffer.data());
 966                         deMemset(rectanglesBuffer.data(), GUARD_VALUE, rectanglesBuffer.size());
 967
 968                         VK_CHECK(instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &rectCount, presentRectangles));
 969
 970                         // Guard check
 971                         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
 972                         {
 973                                 if (rectanglesBuffer[ndx + sizeof(VkRect2D) * rectCount] != GUARD_VALUE)
 974                                 {
 975                                         log << TestLog::Message << "getPhysicalDevicePresentRectanglesKHR - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
 976                                         return tcu::TestStatus::fail("getPhysicalDevicePresentRectanglesKHR buffer overflow");
 977                                 }
 978                         }
 979
 980                         // Check rectangles do not overlap
 981                         for (size_t rectIdx1 = 0; rectIdx1 < rectCount; rectIdx1++)
 982                         {
 983                                 for (size_t rectIdx2 = 0; rectIdx2 < rectCount; rectIdx2++)
 984                                 {
 985                                         if (rectIdx1 != rectIdx2)
 986                                         {
 987                                                 deUint32 rectATop               = presentRectangles[rectIdx1].offset.y;
 988                                                 deUint32 rectALeft              = presentRectangles[rectIdx1].offset.x;
 989                                                 deUint32 rectABottom    = presentRectangles[rectIdx1].offset.y + presentRectangles[rectIdx1].extent.height;
 990                                                 deUint32 rectARight             = presentRectangles[rectIdx1].offset.x + presentRectangles[rectIdx1].extent.width;
 991
 992                                                 deUint32 rectBTop               = presentRectangles[rectIdx2].offset.y;
 993                                                 deUint32 rectBLeft              = presentRectangles[rectIdx2].offset.x;
 994                                                 deUint32 rectBBottom    = presentRectangles[rectIdx2].offset.y + presentRectangles[rectIdx2].extent.height;
 995                                                 deUint32 rectBRight             = presentRectangles[rectIdx2].offset.x + presentRectangles[rectIdx2].extent.width;
 996
 997                                                 if (rectALeft < rectBRight && rectARight > rectBLeft &&
 998                                                         rectATop < rectBBottom && rectABottom > rectBTop)
 999                                                         return tcu::TestStatus::fail("getPhysicalDevicePresentRectanglesKHR rectangles overlap");
1000                                         }
1001                                 }
1002                         }
1003
1004                         // Check incomplete
1005                         incompleteRectCount = rectCount / 2;
1006                         result = instHelper.vki.getPhysicalDevicePresentRectanglesKHR(deviceGroupProps[devGroupIdx].physicalDevices[physDevIdx], *surface, &incompleteRectCount, presentRectangles);
1007                         results.check(result == VK_INCOMPLETE, "Expected VK_INCOMPLETE");
1008                 }
1009         }
1010         return tcu::TestStatus(results.getResult(), results.getMessage());
1011 }
1012
1013 tcu::TestStatus createSurfaceInitialSizeTest (Context& context, Type wsiType)
1014 {
1015         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
1016         tcu::ResultCollector                    results                 (log);
1017
1018         const InstanceHelper                    instHelper              (context, wsiType);
1019
1020         const UniquePtr<Display>                nativeDisplay   (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(),
1021                                                                                                                                    instHelper.supportedExtensions,
1022                                                                                                                                    wsiType));
1023
1024         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
1025         const UVec2                                             sizes[]                 =
1026         {
1027                 UVec2(64, 64),
1028                 UVec2(124, 119),
1029                 UVec2(256, 512)
1030         };
1031
1032         DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE);
1033
1034         for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
1035         {
1036                 const UVec2&                            testSize                = sizes[sizeNdx];
1037                 const UniquePtr<Window>         nativeWindow    (createWindow(*nativeDisplay, tcu::just(testSize)));
1038                 const Unique<VkSurfaceKHR>      surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
1039
1040                 for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
1041                 {
1042                         if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
1043                         {
1044                                 const VkSurfaceCapabilitiesKHR  capabilities    = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface);
1045
1046                                 // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform
1047                                 results.check(capabilities.currentExtent.width == testSize.x() &&
1048                                                                 capabilities.currentExtent.height == testSize.y(),
1049                                                                 "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize));
1050                         }
1051                 }
1052         }
1053
1054         return tcu::TestStatus(results.getResult(), results.getMessage());
1055 }
1056
1057 tcu::TestStatus resizeSurfaceTest (Context& context, Type wsiType)
1058 {
1059         tcu::TestLog&                                   log                             = context.getTestContext().getLog();
1060         tcu::ResultCollector                    results                 (log);
1061
1062         const InstanceHelper                    instHelper              (context, wsiType);
1063
1064         const UniquePtr<Display>                nativeDisplay   (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(),
1065                                                                                                                                    instHelper.supportedExtensions,
1066                                                                                                                                    wsiType));
1067         UniquePtr<Window>                               nativeWindow    (createWindow(*nativeDisplay, tcu::nothing<UVec2>()));
1068
1069         const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
1070         const Unique<VkSurfaceKHR>              surface                 (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
1071
1072         const UVec2                                             sizes[]                 =
1073         {
1074                 UVec2(64, 64),
1075                 UVec2(124, 119),
1076                 UVec2(256, 512)
1077         };
1078
1079         DE_ASSERT(getPlatformProperties(wsiType).features & PlatformProperties::FEATURE_RESIZE_WINDOW);
1080
1081         for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
1082         {
1083                 const UVec2             testSize        = sizes[sizeNdx];
1084
1085                 try
1086                 {
1087                         nativeWindow->resize(testSize);
1088                 }
1089                 catch (const tcu::Exception& e)
1090                 {
1091                         // Make sure all exception types result in a test failure
1092                         results.fail(e.getMessage());
1093                 }
1094
1095                 for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
1096                 {
1097                         if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
1098                         {
1099                                 const VkSurfaceCapabilitiesKHR  capabilities    = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, physicalDevices[deviceNdx], *surface);
1100
1101                                 // \note Assumes that surface size is NOT set by swapchain if initial window size is honored by platform
1102                                 results.check(capabilities.currentExtent.width == testSize.x() &&
1103                                                                 capabilities.currentExtent.height == testSize.y(),
1104                                                                 "currentExtent " + de::toString(capabilities.currentExtent) + " doesn't match requested size " + de::toString(testSize));
1105                         }
1106                 }
1107         }
1108
1109         return tcu::TestStatus(results.getResult(), results.getMessage());
1110 }
1111
1112 tcu::TestStatus destroyNullHandleSurfaceTest (Context& context, Type wsiType)
1113 {
1114         const InstanceHelper    instHelper      (context, wsiType);
1115         const VkSurfaceKHR              nullHandle      = DE_NULL;
1116
1117         // Default allocator
1118         instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, DE_NULL);
1119
1120         // Custom allocator
1121         {
1122                 AllocationCallbackRecorder      recordingAllocator      (getSystemAllocator(), 1u);
1123
1124                 instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, recordingAllocator.getCallbacks());
1125
1126                 if (recordingAllocator.getNumRecords() != 0u)
1127                         return tcu::TestStatus::fail("Implementation allocated/freed the memory");
1128         }
1129
1130         return tcu::TestStatus::pass("Destroying a VK_NULL_HANDLE surface has no effect");
1131 }
1132
1133 } // anonymous
1134
1135 void createSurfaceTests (tcu::TestCaseGroup* testGroup, vk::wsi::Type wsiType)
1136 {
1137         const PlatformProperties&       platformProperties      = getPlatformProperties(wsiType);
1138
1139         addFunctionCase(testGroup, "create",                                                            "Create surface",                                                                                       createSurfaceTest,                                                      wsiType);
1140         addFunctionCase(testGroup, "create_custom_allocator",                           "Create surface with custom allocator",                                         createSurfaceCustomAllocatorTest,                       wsiType);
1141         addFunctionCase(testGroup, "create_simulate_oom",                                       "Create surface with simulating OOM",                                           createSurfaceSimulateOOMTest,                           wsiType);
1142         addFunctionCase(testGroup, "query_support",                                                     "Query surface support",                                                                        querySurfaceSupportTest,                                        wsiType);
1143         addFunctionCase(testGroup, "query_capabilities",                                        "Query surface capabilities",                                                           querySurfaceCapabilitiesTest,                           wsiType);
1144         addFunctionCase(testGroup, "query_capabilities2",                                       "Query extended surface capabilities",                                          querySurfaceCapabilities2Test,                          wsiType);
1145         addFunctionCase(testGroup, "query_formats",                                                     "Query surface formats",                                                                        querySurfaceFormatsTest,                                        wsiType);
1146         addFunctionCase(testGroup, "query_formats2",                                            "Query extended surface formats",                                                       querySurfaceFormats2Test,                                       wsiType);
1147         addFunctionCase(testGroup, "query_present_modes",                                       "Query surface present modes",                                                          querySurfacePresentModesTest,                           wsiType);
1148         addFunctionCase(testGroup, "query_devgroup_present_capabilities",       "Query surface present modes capabilities in device groups",queryDevGroupSurfacePresentCapabilitiesTest,wsiType);
1149         addFunctionCase(testGroup, "query_devgroup_present_modes",                      "Query surface present modes for device groups",                        queryDevGroupSurfacePresentModesTest,           wsiType);
1150         addFunctionCase(testGroup, "destroy_null_handle",                                       "Destroy VK_NULL_HANDLE surface",                                                       destroyNullHandleSurfaceTest,                           wsiType);
1151
1152         if ((platformProperties.features & PlatformProperties::FEATURE_INITIAL_WINDOW_SIZE) != 0)
1153                 addFunctionCase(testGroup, "initial_size",      "Create surface with initial window size set",  createSurfaceInitialSizeTest,   wsiType);
1154
1155         if ((platformProperties.features & PlatformProperties::FEATURE_RESIZE_WINDOW) != 0)
1156                 addFunctionCase(testGroup, "resize",            "Resize window and surface",                                    resizeSurfaceTest,                              wsiType);
1157 }
1158
1159 } // wsi
1160 } // vkt