diff --git a/src/Magnum/Vk/Assert.h b/src/Magnum/Vk/Assert.h index dee0f9cf3..a3f30856e 100644 --- a/src/Magnum/Vk/Assert.h +++ b/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 #include @@ -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(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); \ - if(_CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) != Magnum::Vk::Result::Success) { \ + const Magnum::Vk::Result _CORRADE_HELPER_PASTE(magnumVkResult, __LINE__) = Magnum::Vk::Result(call); \ + 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(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(); \ } \ diff --git a/src/Magnum/Vk/CommandBuffer.cpp b/src/Magnum/Vk/CommandBuffer.cpp index 9f6307595..ffd92628e 100644 --- a/src/Magnum/Vk/CommandBuffer.cpp +++ b/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() { diff --git a/src/Magnum/Vk/CommandPool.cpp b/src/Magnum/Vk/CommandPool.cpp index de72a6fc6..3008f7bb2 100644 --- a/src/Magnum/Vk/CommandPool.cpp +++ b/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() { diff --git a/src/Magnum/Vk/Device.cpp b/src/Magnum/Vk/Device.cpp index 5005cb20a..f2834c65e 100644 --- a/src/Magnum/Vk/Device.cpp +++ b/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({info->ppEnabledExtensionNames, info->enabledExtensionCount}); initialize(instance, version); diff --git a/src/Magnum/Vk/DeviceProperties.cpp b/src/Magnum/Vk/DeviceProperties.cpp index 3b07bfae9..46b95f277 100644 --- a/src/Magnum/Vk/DeviceProperties.cpp +++ b/src/Magnum/Vk/DeviceProperties.cpp @@ -318,12 +318,12 @@ Containers::Optional DeviceProperties::tryPickMemory(const MemoryFl Containers::Array 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 out{Containers::NoInit, count}; Containers::ArrayView handles{reinterpret_cast(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()); diff --git a/src/Magnum/Vk/ExtensionProperties.cpp b/src/Magnum/Vk/ExtensionProperties.cpp index 2846761b1..1fbc8c46b 100644 --- a/src/Magnum/Vk/ExtensionProperties.cpp +++ b/src/Magnum/Vk/ExtensionProperties.cpp @@ -49,7 +49,7 @@ ExtensionProperties::ExtensionProperties(const Containers::ArrayView(_extensions.data()) + offset)); diff --git a/src/Magnum/Vk/Image.cpp b/src/Magnum/Vk/Image.cpp index 224c36a60..c7ae90e09 100644 --- a/src/Magnum/Vk/Image.cpp +++ b/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} {} diff --git a/src/Magnum/Vk/Instance.cpp b/src/Magnum/Vk/Instance.cpp index 3692005c6..1d0dd1a63 100644 --- a/src/Magnum/Vk/Instance.cpp +++ b/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({info->ppEnabledExtensionNames, info->enabledExtensionCount}); if(info._state) diff --git a/src/Magnum/Vk/LayerProperties.cpp b/src/Magnum/Vk/LayerProperties.cpp index 2faa3155d..4f8efbaf7 100644 --- a/src/Magnum/Vk/LayerProperties.cpp +++ b/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(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()); diff --git a/src/Magnum/Vk/Memory.cpp b/src/Magnum/Vk/Memory.cpp index 101ea42a0..314ce807e 100644 --- a/src/Magnum/Vk/Memory.cpp +++ b/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{} {} diff --git a/src/Magnum/Vk/Test/AssertDisabledTest.cpp b/src/Magnum/Vk/Test/AssertDisabledTest.cpp index 3ea196b89..06805350a 100644 --- a/src/Magnum/Vk/Test/AssertDisabledTest.cpp +++ b/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 vkResult(); + void success(); + void successOrIncomplete(); + void vkSuccess(); + void vkSuccessOrIncomplete(); }; AssertDisabledTest::AssertDisabledTest() { - addTests({&AssertDisabledTest::result, - &AssertDisabledTest::vkResult}); + addTests({&AssertDisabledTest::success, + &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(), ""); } diff --git a/src/Magnum/Vk/Test/AssertTest.cpp b/src/Magnum/Vk/Test/AssertTest.cpp index 33c1ab43f..0add9ed65 100644 --- a/src/Magnum/Vk/Test/AssertTest.cpp +++ b/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 vkResult(); + void success(); + 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, - &AssertTest::vkResult}); + addTests({&AssertTest::success, + &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") - .addOption("assert-vk-result", "false").setHelp("assert-vk-result", "fail on MAGNUM_VK_INTERNAL_ASSERT_RESULT() with VkResult", "BOOL") + args.addOption("assert-success", "false").setHelp("assert-success", "fail on MAGNUM_VK_INTERNAL_ASSERT_SUCCESS() with Vk::Result", "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("assert-result"); - _failAssertVkResult = args.value("assert-vk-result"); + _failAssertSuccess = args.value("assert-success"); + _failAssertSuccessOrIncomplete = args.value("assert-success-or-incomplete"); + _failAssertVkSuccess = args.value("assert-vk-success"); + _failAssertVkSuccessOrIncomplete = args.value("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; - MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); + Result r = _failAssertSuccess ? Result::ErrorFragmentedPool : Result::Success; + 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; - MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = s); + VkResult s = _failAssertVkSuccess ? VK_ERROR_FRAGMENTED_POOL : VK_SUCCESS; + 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) diff --git a/src/Magnum/Vk/Test/CMakeLists.txt b/src/Magnum/Vk/Test/CMakeLists.txt index fd8563d7e..af459e963 100644 --- a/src/Magnum/Vk/Test/CMakeLists.txt +++ b/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 $ ${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 $ ${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 + $ + ${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 + $ + ${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 diff --git a/src/Magnum/Vk/Version.cpp b/src/Magnum/Vk/Version.cpp index b12ad699d..cc478b06d 100644 --- a/src/Magnum/Vk/Version.cpp +++ b/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); }