Vk: rename the *ASSERT_{RESULT => SUCCESS}(), add an incomplete variant.

We'll need that to optimize some commands, such as device enumeration.

src/Magnum/Vk/Assert.h

@@ -26,7 +26,7 @@
 */
 
 /** @file
- * @brief Macro @ref MAGNUM_VK_INTERNAL_ASSERT_RESULT()
+ * @brief Macro @ref MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(), @ref MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE()
  * @m_since_latest
  */
 
@@ -35,7 +35,7 @@
 
 #include "Magnum/configure.h"
 
-#if !defined(CORRADE_NO_ASSERT) && !defined(MAGNUM_VK_INTERNAL_ASSERT_RESULT)
+#if !defined(CORRADE_NO_ASSERT) && (!defined(MAGNUM_VK_INTERNAL_ASSERT_SUCCESS) || !defined(MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE))
 #ifndef CORRADE_STANDARD_ASSERT
 #include <cstdlib>
 #include <Corrade/Utility/Debug.h>
@@ -58,21 +58,56 @@ Vulkan functions returning @type_vk{Result} and APIs returning
 @ref Magnum::Vk::Result "Vk::Result".
 
 You can override this implementation by placing your own
-@cpp #define MAGNUM_VK_INTERNAL_ASSERT_RESULT @ce before including the
+@cpp #define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS @ce before including the
 @ref Magnum/Vk/Assert.h header.
+@see @ref MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE()
 */
-#ifndef MAGNUM_VK_INTERNAL_ASSERT_RESULT
+#ifndef MAGNUM_VK_INTERNAL_ASSERT_SUCCESS
 #if defined(CORRADE_NO_ASSERT) || (defined(CORRADE_STANDARD_ASSERT) && defined(NDEBUG))
-#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call)                              \
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(call)                             \
     static_cast<void>(call)
 #elif defined(CORRADE_STANDARD_ASSERT)
-#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call)                              \
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(call)                             \
     assert(Magnum::Vk::Result(call) == Magnum::Vk::Result::Success)
 #else
-#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call)                              \
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(call)                             \
     do {                                                                    \
-        const Magnum::Vk::Result _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) = Magnum::Vk::Result(call);         \
+        const Magnum::Vk::Result _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) = Magnum::Vk::Result(call); \
-        if(_CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) != Magnum::Vk::Result::Success) {                                                       \
+        if(_CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) != Magnum::Vk::Result::Success) { \
+            Corrade::Utility::Error{Corrade::Utility::Error::defaultOutput()} << "Call " #call " failed with" << _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) << "at " __FILE__ ":" CORRADE_LINE_STRING; \
+            std::abort();                                                   \
+        }                                                                   \
+    } while(false)
+#endif
+#endif
+
+/**
+@brief Assert that a Vulkan function call succeeds or returns incomplete data
+@m_since_latest
+
+A variant of @ref MAGNUM_VK_INTERNAL_ASSERT_SUCCESS() that allows the call to
+return @ref Magnum::Vk::Result::Incomplete "Vk::Result::Incomplete" in addition
+to @ref Magnum::Vk::Result::Success "Vk::Result::Success".
+
+You can override this implementation by placing your own
+@cpp #define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE @ce before
+including the @ref Magnum/Vk/Assert.h header.
+*/
+#ifndef MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE
+#if defined(CORRADE_NO_ASSERT) || (defined(CORRADE_STANDARD_ASSERT) && defined(NDEBUG))
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(call)               \
+    static_cast<void>(call)
+#elif defined(CORRADE_STANDARD_ASSERT)
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(call)               \
+    do {                                                                    \
+        const Magnum::Vk::Result _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) = Magnum::Vk::Result(call); \
+        assert(_CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) == Magnum::Vk::Result::Success || _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) == Magnum::Vk::Result::Incomplete);    \
+    } while(false)
+#else
+#define MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(call)               \
+    do {                                                                    \
+        const Magnum::Vk::Result _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) = Magnum::Vk::Result(call); \
+        if(_CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) != Magnum::Vk::Result::Success && _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) != Magnum::Vk::Result::Incomplete) { \
             Corrade::Utility::Error{Corrade::Utility::Error::defaultOutput()} << "Call " #call " failed with" << _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) << "at " __FILE__ ":" CORRADE_LINE_STRING; \
             std::abort();                                                   \
         }                                                                   \

src/Magnum/Vk/CommandBuffer.cpp

@@ -61,7 +61,7 @@ CommandBuffer& CommandBuffer::operator=(CommandBuffer&& other) noexcept {
 }
 
 void CommandBuffer::reset(const CommandBufferResetFlags flags) {
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT((**_device).ResetCommandBuffer(_handle, VkCommandBufferResetFlags(flags)));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS((**_device).ResetCommandBuffer(_handle, VkCommandBufferResetFlags(flags)));
 }
 
 VkCommandBuffer CommandBuffer::release() {

src/Magnum/Vk/CommandPool.cpp

@@ -54,7 +54,7 @@ CommandPool CommandPool::wrap(Device& device, const VkCommandPool handle, const
 }
 
 CommandPool::CommandPool(Device& device, const CommandPoolCreateInfo& info): _device{&device}, _flags{HandleFlag::DestroyOnDestruction} {
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(device->CreateCommandPool(device, info, nullptr, &_handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateCommandPool(device, info, nullptr, &_handle));
 }
 
 CommandPool::CommandPool(NoCreateT) noexcept: _device{}, _handle{} {}
@@ -87,13 +87,13 @@ CommandBuffer CommandPool::allocate(const CommandBufferLevel level) {
     info.commandPool = _handle;
     info.commandBufferCount = 1;
     info.level = VkCommandBufferLevel(level);
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT((**_device).AllocateCommandBuffers(*_device, &info, &out._handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS((**_device).AllocateCommandBuffers(*_device, &info, &out._handle));
 
     return out;
 }
 
 void CommandPool::reset(const CommandPoolResetFlags flags) {
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT((**_device).ResetCommandPool(*_device, _handle, VkCommandPoolResetFlags(flags)));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS((**_device).ResetCommandPool(*_device, _handle, VkCommandPoolResetFlags(flags)));
 }
 
 VkCommandPool CommandPool::release() {

src/Magnum/Vk/Device.cpp

@@ -331,7 +331,7 @@ Device::Device(Instance& instance, const DeviceCreateInfo& info, DevicePropertie
         }
     }
 
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(instance->CreateDevice(info._physicalDevice, info, nullptr, &_handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(instance->CreateDevice(info._physicalDevice, info, nullptr, &_handle));
 
     initializeExtensions<const char*>({info->ppEnabledExtensionNames, info->enabledExtensionCount});
     initialize(instance, version);

src/Magnum/Vk/DeviceProperties.cpp

@@ -318,12 +318,12 @@ Containers::Optional<UnsignedInt> DeviceProperties::tryPickMemory(const MemoryFl
 Containers::Array<DeviceProperties> enumerateDevices(Instance& instance) {
     /* Retrieve total device count */
     UnsignedInt count;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(instance->EnumeratePhysicalDevices(instance, &count, nullptr));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(instance->EnumeratePhysicalDevices(instance, &count, nullptr));
 
     /* Allocate memory for the output, fetch the handles into it */
     Containers::Array<DeviceProperties> out{Containers::NoInit, count};
     Containers::ArrayView<VkPhysicalDevice> handles{reinterpret_cast<VkPhysicalDevice*>(out.data()), count};
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(instance->EnumeratePhysicalDevices(instance, &count, handles.data()));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(instance->EnumeratePhysicalDevices(instance, &count, handles.data()));
 
     /* Expect the device count didn't change between calls */
     CORRADE_INTERNAL_ASSERT(count == out.size());

src/Magnum/Vk/ExtensionProperties.cpp

@@ -49,7 +49,7 @@ ExtensionProperties::ExtensionProperties(const Containers::ArrayView<const Conta
     std::size_t totalCount = 0;
     for(std::size_t i = 0; i <= layers.size(); ++i) {
         UnsignedInt count;
-        MAGNUM_VK_INTERNAL_ASSERT_RESULT(enumerator(state,
+        MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(enumerator(state,
             i == 0 ? nullptr :
                 Containers::String::nullTerminatedView(layers[i - 1]).data(),
             &count, nullptr));
@@ -73,7 +73,7 @@ ExtensionProperties::ExtensionProperties(const Containers::ArrayView<const Conta
     std::size_t offset = 0;
     for(std::size_t i = 0; i <= layers.size(); ++i) {
         UnsignedInt count = totalCount - offset;
-        MAGNUM_VK_INTERNAL_ASSERT_RESULT(enumerator(state,
+        MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(enumerator(state,
             i == 0 ? nullptr :
                 Containers::String::nullTerminatedView(layers[i - 1]).data(),
             &count, reinterpret_cast<VkExtensionProperties*>(_extensions.data()) + offset));

src/Magnum/Vk/Image.cpp

@@ -75,7 +75,7 @@ Image Image::wrap(Device& device, const VkImage handle, const HandleFlags flags)
 }
 
 Image::Image(Device& device, const ImageCreateInfo& info, NoAllocateT): _device{&device}, _flags{HandleFlag::DestroyOnDestruction}, _dedicatedMemory{NoCreate} {
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(device->CreateImage(device, info, nullptr, &_handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateImage(device, info, nullptr, &_handle));
 }
 
 Image::Image(NoCreateT): _device{}, _handle{}, _dedicatedMemory{NoCreate} {}

src/Magnum/Vk/Instance.cpp

@@ -292,7 +292,7 @@ Instance::Instance(const InstanceCreateInfo& info): _flags{HandleFlag::DestroyOn
         }
     }
 
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(vkCreateInstance(info, nullptr, &_handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(vkCreateInstance(info, nullptr, &_handle));
 
     initializeExtensions<const char*>({info->ppEnabledExtensionNames, info->enabledExtensionCount});
     if(info._state)

src/Magnum/Vk/LayerProperties.cpp

@@ -88,7 +88,7 @@ LayerProperties enumerateLayerProperties() {
 
     /* Retrieve layer count */
     UnsignedInt count;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(vkEnumerateInstanceLayerProperties(&count, nullptr));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(vkEnumerateInstanceLayerProperties(&count, nullptr));
 
     /* No layers, nothing to do */
     if(!count) return out;
@@ -101,7 +101,7 @@ LayerProperties enumerateLayerProperties() {
         [](VkLayerProperties* data, std::size_t) {
             delete[] reinterpret_cast<char*>(data);
         }};
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(vkEnumerateInstanceLayerProperties(&count, out._layers.data()));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(vkEnumerateInstanceLayerProperties(&count, out._layers.data()));
 
     /* Expect the layer count didn't change between calls */
     CORRADE_INTERNAL_ASSERT(count == out._layers.size());

src/Magnum/Vk/Memory.cpp

@@ -67,7 +67,7 @@ Memory Memory::wrap(Device& device, const VkDeviceMemory handle, const HandleFla
 }
 
 Memory::Memory(Device& device, const MemoryAllocateInfo& info): _device{&device}, _flags{HandleFlag::DestroyOnDestruction} {
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(device->AllocateMemory(device, info, nullptr, &_handle));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->AllocateMemory(device, info, nullptr, &_handle));
 }
 
 Memory::Memory(NoCreateT): _device{}, _handle{} {}

src/Magnum/Vk/Test/AssertDisabledTest.cpp

@@ -40,40 +40,68 @@ namespace Magnum { namespace Vk { namespace Test { namespace {
 struct AssertDisabledTest: TestSuite::Tester {
     explicit AssertDisabledTest();
 
-    void result();
+    void success();
-    void vkResult();
+    void successOrIncomplete();
+    void vkSuccess();
+    void vkSuccessOrIncomplete();
 };
 
 AssertDisabledTest::AssertDisabledTest() {
-    addTests({&AssertDisabledTest::result,
+    addTests({&AssertDisabledTest::success,
-              &AssertDisabledTest::vkResult});
+              &AssertDisabledTest::successOrIncomplete,
+              &AssertDisabledTest::vkSuccess,
+              &AssertDisabledTest::vkSuccessOrIncomplete});
 
     #ifdef CORRADE_STANDARD_ASSERT
     setTestName("Magum::Vk::Test::AssertStandardDisabledTest");
     #endif
 }
 
-void AssertDisabledTest::result() {
+void AssertDisabledTest::success() {
     std::ostringstream out;
     Error redirectError{&out};
 
     Result a = Result::ErrorUnknown;
     Result r = Result::ErrorFragmentedPool;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r);
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(a = r);
-
     CORRADE_COMPARE(a, Result::ErrorFragmentedPool);
+
+    CORRADE_COMPARE(out.str(), "");
+}
+
+void AssertDisabledTest::successOrIncomplete() {
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Result a = Result::ErrorUnknown;
+    Result r = Result::ErrorExtensionNotPresent;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(a = r);
+    CORRADE_COMPARE(a, Result::ErrorExtensionNotPresent);
+
     CORRADE_COMPARE(out.str(), "");
 }
 
-void AssertDisabledTest::vkResult() {
+void AssertDisabledTest::vkSuccess() {
     std::ostringstream out;
     Error redirectError{&out};
 
     VkResult a = VK_ERROR_UNKNOWN;
     VkResult r = VK_ERROR_FRAGMENTED_POOL;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r);
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(a = r);
-
     CORRADE_COMPARE(Result(a), Result::ErrorFragmentedPool);
+
+    CORRADE_COMPARE(out.str(), "");
+}
+
+void AssertDisabledTest::vkSuccessOrIncomplete() {
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    VkResult b = VK_ERROR_UNKNOWN;
+    VkResult s = VK_ERROR_EXTENSION_NOT_PRESENT;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(b = s);
+    CORRADE_COMPARE(Result(b), Result::ErrorExtensionNotPresent);
+
     CORRADE_COMPARE(out.str(), "");
 }
 

src/Magnum/Vk/Test/AssertTest.cpp

@@ -38,47 +38,76 @@ namespace Magnum { namespace Vk { namespace Test { namespace {
 struct AssertTest: TestSuite::Tester {
     explicit AssertTest();
 
-    void result();
+    void success();
-    void vkResult();
+    void successOrIncomplete();
+    void vkSuccess();
+    void vkSuccessOrIncomplete();
 
-    bool _failAssertResult, _failAssertVkResult;
+    bool _failAssertSuccess, _failAssertSuccessOrIncomplete,
+        _failAssertVkSuccess, _failAssertVkSuccessOrIncomplete;
 };
 
 AssertTest::AssertTest(): TestSuite::Tester{TesterConfiguration{}.setSkippedArgumentPrefixes({"fail-on"})} {
-    addTests({&AssertTest::result,
+    addTests({&AssertTest::success,
-              &AssertTest::vkResult});
+              &AssertTest::successOrIncomplete,
+              &AssertTest::vkSuccess,
+              &AssertTest::vkSuccessOrIncomplete});
 
     Utility::Arguments args{"fail-on"};
-    args.addOption("assert-result", "false").setHelp("assert-result", "fail on MAGNUM_VK_INTERNAL_ASSERT_RESULT() with Vk::Result", "BOOL")
+    args.addOption("assert-success", "false").setHelp("assert-success", "fail on MAGNUM_VK_INTERNAL_ASSERT_SUCCESS() with Vk::Result", "BOOL")
-        .addOption("assert-vk-result", "false").setHelp("assert-vk-result", "fail on MAGNUM_VK_INTERNAL_ASSERT_RESULT() with VkResult", "BOOL")
+        .addOption("assert-success-or-incomplete", "false").setHelp("assert-success", "fail on MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE() with Vk::Result", "BOOL")
+        .addOption("assert-vk-success", "false").setHelp("assert-vk-success", "fail on MAGNUM_VK_INTERNAL_ASSERT_SUCCESS() with VkResult", "BOOL")
+        .addOption("assert-vk-success-or-incomplete", "false").setHelp("assert-vk-success-or-incomplete", "fail on MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE() with VkResult", "BOOL")
         .parse(arguments().first, arguments().second);
 
-    _failAssertResult = args.value<bool>("assert-result");
+    _failAssertSuccess = args.value<bool>("assert-success");
-    _failAssertVkResult = args.value<bool>("assert-vk-result");
+    _failAssertSuccessOrIncomplete = args.value<bool>("assert-success-or-incomplete");
+    _failAssertVkSuccess = args.value<bool>("assert-vk-success");
+    _failAssertVkSuccessOrIncomplete = args.value<bool>("assert-vk-success-or-incomplete");
 
     #ifdef CORRADE_STANDARD_ASSERT
     setTestName("Magum::Vk::Test::AssertStandardTest");
     #endif
 }
 
-void AssertTest::result() {
+void AssertTest::success() {
     Result a = Result::ErrorUnknown;
 
-    Result r = _failAssertResult ? Result::ErrorFragmentedPool : Result::Success;
+    Result r = _failAssertSuccess ? Result::ErrorFragmentedPool : Result::Success;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r);
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(a = r);
 
     CORRADE_COMPARE(a, Result::Success);
 }
 
-void AssertTest::vkResult() {
+void AssertTest::successOrIncomplete() {
+    Result a = Result::ErrorUnknown;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(a = Result::Success);
+
+    Result r = _failAssertSuccessOrIncomplete ? Result::ErrorExtensionNotPresent : Result::Incomplete;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(a = r);
+
+    CORRADE_COMPARE(a, Result::Incomplete);
+}
+
+void AssertTest::vkSuccess() {
     VkResult a = VK_ERROR_UNKNOWN;
 
-    VkResult s = _failAssertVkResult ? VK_ERROR_FRAGMENTED_POOL : VK_SUCCESS;
+    VkResult s = _failAssertVkSuccess ? VK_ERROR_FRAGMENTED_POOL : VK_SUCCESS;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = s);
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(a = s);
 
     CORRADE_COMPARE(Result(a), Result::Success);
 }
 
+void AssertTest::vkSuccessOrIncomplete() {
+    VkResult a = VK_ERROR_UNKNOWN;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(a = VK_SUCCESS);
+
+    VkResult s = _failAssertVkSuccessOrIncomplete ? VK_ERROR_EXTENSION_NOT_PRESENT : VK_INCOMPLETE;
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS_OR_INCOMPLETE(a = s);
+
+    CORRADE_COMPARE(Result(a), Result::Incomplete);
+}
+
 }}}}
 
 CORRADE_TEST_MAIN(Magnum::Vk::Test::AssertTest)

src/Magnum/Vk/Test/CMakeLists.txt

@@ -50,20 +50,34 @@ corrade_add_test(VkAssertTest
 # times with different arguments, but corrade_add_test() doesn't support that,
 # so I'm doing it at least via an OBJECT library.
 if(CORRADE_TARGET_ANDROID)
-    corrade_add_test(VkAssertTestFailAssertResult
+    corrade_add_test(VkAssertTestFailAssertSuccess
         $<TARGET_OBJECTS:VkAssertTestObjects>
         ${PROJECT_SOURCE_DIR}/src/dummy.cpp
-        ARGUMENTS --fail-on-assert-result true
+        ARGUMENTS --fail-on-assert-success true
         LIBRARIES MagnumVk)
-    set_tests_properties(VkAssertTestFailAssertResult PROPERTIES
+    set_tests_properties(VkAssertTestFailAssertSuccess PROPERTIES
         PASS_REGULAR_EXPRESSION "Call a = r failed with Vk::Result::ErrorFragmentedPool at ")
-    corrade_add_test(VkAssertTestFailAssertVkResult
+    corrade_add_test(VkAssertTestFailAssertSucce___Incomplete
         $<TARGET_OBJECTS:VkAssertTestObjects>
         ${PROJECT_SOURCE_DIR}/src/dummy.cpp
-        ARGUMENTS --fail-on-assert-vk-result true
+        ARGUMENTS --fail-on-assert-success-or-incomplete true
         LIBRARIES MagnumVk)
-    set_tests_properties(VkAssertTestFailAssertVkResult PROPERTIES
+    set_tests_properties(VkAssertTestFailAssertSucce___Incomplete PROPERTIES
+        PASS_REGULAR_EXPRESSION "Call a = r failed with Vk::Result::ErrorExtensionNotPresent at ")
+    corrade_add_test(VkAssertTestFailAssertVkSuccess
+        $<TARGET_OBJECTS:VkAssertTestObjects>
+        ${PROJECT_SOURCE_DIR}/src/dummy.cpp
+        ARGUMENTS --fail-on-assert-vk-success true
+        LIBRARIES MagnumVk)
+    set_tests_properties(VkAssertTestFailAssertVkSuccess PROPERTIES
         PASS_REGULAR_EXPRESSION "Call a = s failed with Vk::Result::ErrorFragmentedPool at ")
+    corrade_add_test(VkAssertTestFailAssertVkSuc___Incomplete
+        $<TARGET_OBJECTS:VkAssertTestObjects>
+        ${PROJECT_SOURCE_DIR}/src/dummy.cpp
+        ARGUMENTS --fail-on-assert-vk-success-or-incomplete true
+        LIBRARIES MagnumVk)
+    set_tests_properties(VkAssertTestFailAssertVkSuc___Incomplete PROPERTIES
+        PASS_REGULAR_EXPRESSION "Call a = s failed with Vk::Result::ErrorExtensionNotPresent at ")
 endif()
 
 # The same as above, but using CORRADE_STANDARD_ASSERT

src/Magnum/Vk/Version.cpp

@@ -47,7 +47,7 @@ Version enumerateInstanceVersion() {
     if(!vkEnumerateInstanceVersion) return Version::Vk10;
 
     UnsignedInt version;
-    MAGNUM_VK_INTERNAL_ASSERT_RESULT(vkEnumerateInstanceVersion(&version));
+    MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(vkEnumerateInstanceVersion(&version));
     return Version(version);
 }