From 86267f1a78162dae836f7b8efb4fef5d71c9e43a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sat, 14 Nov 2020 23:37:29 +0100 Subject: [PATCH] Vk: move MAGNUM_VK_INTERNAL_ASSER_RESULT() to a dedicated header. Similarly to Corrade Assert.h, so it's possible to include this header without having to worry about irrelevant overhead when asserts are disabled. Also test it properly, as it should have been from the start. --- src/Magnum/Vk/Assert.h | 83 ++++++++++++++++++++++ src/Magnum/Vk/CMakeLists.txt | 1 + src/Magnum/Vk/CommandBuffer.cpp | 2 +- src/Magnum/Vk/CommandPool.cpp | 2 +- src/Magnum/Vk/Device.cpp | 2 +- src/Magnum/Vk/DeviceProperties.cpp | 2 +- src/Magnum/Vk/ExtensionProperties.cpp | 2 +- src/Magnum/Vk/Image.cpp | 2 +- src/Magnum/Vk/Instance.cpp | 2 +- src/Magnum/Vk/LayerProperties.cpp | 2 +- src/Magnum/Vk/Memory.cpp | 2 +- src/Magnum/Vk/Result.h | 41 +---------- src/Magnum/Vk/Test/AssertDisabledTest.cpp | 82 ++++++++++++++++++++++ src/Magnum/Vk/Test/AssertTest.cpp | 84 +++++++++++++++++++++++ src/Magnum/Vk/Test/CMakeLists.txt | 39 +++++++++++ src/Magnum/Vk/Test/ResultTest.cpp | 40 ++--------- src/Magnum/Vk/Version.cpp | 3 +- 17 files changed, 306 insertions(+), 85 deletions(-) create mode 100644 src/Magnum/Vk/Assert.h create mode 100644 src/Magnum/Vk/Test/AssertDisabledTest.cpp create mode 100644 src/Magnum/Vk/Test/AssertTest.cpp diff --git a/src/Magnum/Vk/Assert.h b/src/Magnum/Vk/Assert.h new file mode 100644 index 000000000..dee0f9cf3 --- /dev/null +++ b/src/Magnum/Vk/Assert.h @@ -0,0 +1,83 @@ +#ifndef Magnum_Vk_Assert_h +#define Magnum_Vk_Assert_h +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020 Vladimír Vondruš + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +/** @file + * @brief Macro @ref MAGNUM_VK_INTERNAL_ASSERT_RESULT() + * @m_since_latest + */ + +#include +#include + +#include "Magnum/configure.h" + +#if !defined(CORRADE_NO_ASSERT) && !defined(MAGNUM_VK_INTERNAL_ASSERT_RESULT) +#ifndef CORRADE_STANDARD_ASSERT +#include +#include + +#include "Magnum/Vk/Result.h" +#elif !defined(NDEBUG) +#include +#endif +#endif + +/** +@brief Assert that a Vulkan function call succeeds +@m_since_latest + +Compared to using @ref CORRADE_INTERNAL_ASSERT_OUTPUT() to verify that +@cpp call == VK_SUCCESS @ce, this macro also prints the result value. Otherwise +the behavior is the same, including interactions with +@ref CORRADE_STANDARD_ASSERT and @ref CORRADE_NO_ASSERT. Works with both plain +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 +@ref Magnum/Vk/Assert.h header. +*/ +#ifndef MAGNUM_VK_INTERNAL_ASSERT_RESULT +#if defined(CORRADE_NO_ASSERT) || (defined(CORRADE_STANDARD_ASSERT) && defined(NDEBUG)) +#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call) \ + static_cast(call) +#elif defined(CORRADE_STANDARD_ASSERT) +#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call) \ + assert(Magnum::Vk::Result(call) == Magnum::Vk::Result::Success) +#else +#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(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::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 + +#endif diff --git a/src/Magnum/Vk/CMakeLists.txt b/src/Magnum/Vk/CMakeLists.txt index a709e2c58..c7a6f0d84 100644 --- a/src/Magnum/Vk/CMakeLists.txt +++ b/src/Magnum/Vk/CMakeLists.txt @@ -49,6 +49,7 @@ set(MagnumVk_GracefulAssert_SRCS LayerProperties.cpp) set(MagnumVk_HEADERS + Assert.h CommandBuffer.h CommandPool.h Device.h diff --git a/src/Magnum/Vk/CommandBuffer.cpp b/src/Magnum/Vk/CommandBuffer.cpp index ba563a636..9f6307595 100644 --- a/src/Magnum/Vk/CommandBuffer.cpp +++ b/src/Magnum/Vk/CommandBuffer.cpp @@ -25,9 +25,9 @@ #include "CommandBuffer.h" +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Device.h" #include "Magnum/Vk/Handle.h" -#include "Magnum/Vk/Result.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/CommandPool.cpp b/src/Magnum/Vk/CommandPool.cpp index 625ebc841..de72a6fc6 100644 --- a/src/Magnum/Vk/CommandPool.cpp +++ b/src/Magnum/Vk/CommandPool.cpp @@ -25,10 +25,10 @@ #include "CommandPool.h" +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/CommandBuffer.h" #include "Magnum/Vk/Device.h" #include "Magnum/Vk/Handle.h" -#include "Magnum/Vk/Result.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/Device.cpp b/src/Magnum/Vk/Device.cpp index ff5dfbb4a..5005cb20a 100644 --- a/src/Magnum/Vk/Device.cpp +++ b/src/Magnum/Vk/Device.cpp @@ -35,13 +35,13 @@ #include #include "Magnum/Math/Functions.h" +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Handle.h" #include "Magnum/Vk/Instance.h" #include "Magnum/Vk/DeviceProperties.h" #include "Magnum/Vk/Extensions.h" #include "Magnum/Vk/ExtensionProperties.h" #include "Magnum/Vk/Queue.h" -#include "Magnum/Vk/Result.h" #include "Magnum/Vk/Version.h" #include "Magnum/Vk/Implementation/Arguments.h" #include "Magnum/Vk/Implementation/InstanceState.h" diff --git a/src/Magnum/Vk/DeviceProperties.cpp b/src/Magnum/Vk/DeviceProperties.cpp index e6b0d27bc..3b07bfae9 100644 --- a/src/Magnum/Vk/DeviceProperties.cpp +++ b/src/Magnum/Vk/DeviceProperties.cpp @@ -33,12 +33,12 @@ #include #include "Magnum/Math/Functions.h" +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/ExtensionProperties.h" #include "Magnum/Vk/Extensions.h" #include "Magnum/Vk/Instance.h" #include "Magnum/Vk/LayerProperties.h" #include "Magnum/Vk/Memory.h" -#include "Magnum/Vk/Result.h" #include "Magnum/Vk/Version.h" #include "Magnum/Vk/Implementation/Arguments.h" #include "Magnum/Vk/Implementation/InstanceState.h" diff --git a/src/Magnum/Vk/ExtensionProperties.cpp b/src/Magnum/Vk/ExtensionProperties.cpp index 7cd760c12..2846761b1 100644 --- a/src/Magnum/Vk/ExtensionProperties.cpp +++ b/src/Magnum/Vk/ExtensionProperties.cpp @@ -30,8 +30,8 @@ #include #include +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Extensions.h" -#include "Magnum/Vk/Result.h" #include "Magnum/Vk/Version.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/Image.cpp b/src/Magnum/Vk/Image.cpp index 9757e351a..224c36a60 100644 --- a/src/Magnum/Vk/Image.cpp +++ b/src/Magnum/Vk/Image.cpp @@ -25,10 +25,10 @@ #include "Image.h" +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Device.h" #include "Magnum/Vk/Handle.h" #include "Magnum/Vk/Integration.h" -#include "Magnum/Vk/Result.h" #include "Magnum/Vk/Implementation/DeviceState.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/Instance.cpp b/src/Magnum/Vk/Instance.cpp index 0a105d0ed..3692005c6 100644 --- a/src/Magnum/Vk/Instance.cpp +++ b/src/Magnum/Vk/Instance.cpp @@ -32,10 +32,10 @@ #include #include +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Extensions.h" #include "Magnum/Vk/ExtensionProperties.h" #include "Magnum/Vk/Handle.h" -#include "Magnum/Vk/Result.h" #include "Magnum/Vk/Version.h" #include "Magnum/Vk/Implementation/Arguments.h" #include "Magnum/Vk/Implementation/InstanceState.h" diff --git a/src/Magnum/Vk/LayerProperties.cpp b/src/Magnum/Vk/LayerProperties.cpp index 717d16dd4..2faa3155d 100644 --- a/src/Magnum/Vk/LayerProperties.cpp +++ b/src/Magnum/Vk/LayerProperties.cpp @@ -28,7 +28,7 @@ #include #include -#include "Magnum/Vk/Result.h" +#include "Magnum/Vk/Assert.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/Memory.cpp b/src/Magnum/Vk/Memory.cpp index 0eb299b4d..101ea42a0 100644 --- a/src/Magnum/Vk/Memory.cpp +++ b/src/Magnum/Vk/Memory.cpp @@ -28,9 +28,9 @@ #include #include +#include "Magnum/Vk/Assert.h" #include "Magnum/Vk/Device.h" #include "Magnum/Vk/Handle.h" -#include "Magnum/Vk/Result.h" namespace Magnum { namespace Vk { diff --git a/src/Magnum/Vk/Result.h b/src/Magnum/Vk/Result.h index 9e1fc1149..4a82ca287 100644 --- a/src/Magnum/Vk/Result.h +++ b/src/Magnum/Vk/Result.h @@ -26,13 +26,10 @@ */ /** @file - * @brief Enum @ref Magnum::Vk::Result, macro @ref MAGNUM_VK_INTERNAL_ASSERT_RESULT() + * @brief Enum @ref Magnum::Vk::Result * @m_since_latest */ -#include -#include - #include "Magnum/Magnum.h" #include "Magnum/Vk/visibility.h" #include "Magnum/Vk/Vulkan.h" @@ -45,7 +42,7 @@ namespace Magnum { namespace Vk { Wraps a @type_vk_keyword{Result}. @m_enum_values_as_keywords -@see @ref MAGNUM_VK_INTERNAL_ASSERT_RESULT() +@see @ref MAGNUM_VK_INTERNAL_ASSERT_SUCCESS() */ enum class Result: Int { /** Command successfully completed */ @@ -123,40 +120,6 @@ enum class Result: Int { */ MAGNUM_VK_EXPORT Debug& operator<<(Debug& debug, Result value); -/** -@brief Assert that a Vulkan function call doesn't fail -@m_since_latest - -Compared to using @ref CORRADE_INTERNAL_ASSERT_OUTPUT() to verify that -@cpp call == VK_SUCCESS @ce, this macro also prints the result value. Otherwise -the behavior is the same, including interactions with -@ref CORRADE_STANDARD_ASSERT and @ref CORRADE_NO_ASSERT. Works with both plain -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 -@ref Magnum/Vk/Result.h header. -*/ -#ifndef MAGNUM_VK_INTERNAL_ASSERT_RESULT -#if defined(CORRADE_NO_ASSERT) || (defined(CORRADE_STANDARD_ASSERT) && defined(NDEBUG)) -#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call) \ - static_cast(call) -#elif defined(CORRADE_STANDARD_ASSERT) -#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(call) \ - assert(Magnum::Vk::Result(call) == Magnum::Vk::Result::Success) -#else -#define MAGNUM_VK_INTERNAL_ASSERT_RESULT(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::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 - }} #endif diff --git a/src/Magnum/Vk/Test/AssertDisabledTest.cpp b/src/Magnum/Vk/Test/AssertDisabledTest.cpp new file mode 100644 index 000000000..3ea196b89 --- /dev/null +++ b/src/Magnum/Vk/Test/AssertDisabledTest.cpp @@ -0,0 +1,82 @@ +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020 Vladimír Vondruš + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +#include + +#ifndef CORRADE_STANDARD_ASSERT +#define CORRADE_NO_ASSERT +#endif + +#include +#include + +#include "Magnum/Vk/Assert.h" +#include "Magnum/Vk/Result.h" + +namespace Magnum { namespace Vk { namespace Test { namespace { + +struct AssertDisabledTest: TestSuite::Tester { + explicit AssertDisabledTest(); + + void result(); + void vkResult(); +}; + +AssertDisabledTest::AssertDisabledTest() { + addTests({&AssertDisabledTest::result, + &AssertDisabledTest::vkResult}); + + #ifdef CORRADE_STANDARD_ASSERT + setTestName("Magum::Vk::Test::AssertStandardDisabledTest"); + #endif +} + +void AssertDisabledTest::result() { + std::ostringstream out; + Error redirectError{&out}; + + Result a = Result::ErrorUnknown; + Result r = Result::ErrorFragmentedPool; + MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); + + CORRADE_COMPARE(a, Result::ErrorFragmentedPool); + CORRADE_COMPARE(out.str(), ""); +} + +void AssertDisabledTest::vkResult() { + std::ostringstream out; + Error redirectError{&out}; + + VkResult a = VK_ERROR_UNKNOWN; + VkResult r = VK_ERROR_FRAGMENTED_POOL; + MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); + + CORRADE_COMPARE(Result(a), Result::ErrorFragmentedPool); + CORRADE_COMPARE(out.str(), ""); +} + +}}}} + +CORRADE_TEST_MAIN(Magnum::Vk::Test::AssertDisabledTest) diff --git a/src/Magnum/Vk/Test/AssertTest.cpp b/src/Magnum/Vk/Test/AssertTest.cpp new file mode 100644 index 000000000..33c1ab43f --- /dev/null +++ b/src/Magnum/Vk/Test/AssertTest.cpp @@ -0,0 +1,84 @@ +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020 Vladimír Vondruš + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +#ifdef CORRADE_STANDARD_ASSERT +#undef NDEBUG /* So we can test them */ +#endif + +#include +#include + +#include "Magnum/Vk/Assert.h" +#include "Magnum/Vk/Result.h" + +namespace Magnum { namespace Vk { namespace Test { namespace { + +struct AssertTest: TestSuite::Tester { + explicit AssertTest(); + + void result(); + void vkResult(); + + bool _failAssertResult, _failAssertVkResult; +}; + +AssertTest::AssertTest(): TestSuite::Tester{TesterConfiguration{}.setSkippedArgumentPrefixes({"fail-on"})} { + addTests({&AssertTest::result, + &AssertTest::vkResult}); + + 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") + .parse(arguments().first, arguments().second); + + _failAssertResult = args.value("assert-result"); + _failAssertVkResult = args.value("assert-vk-result"); + + #ifdef CORRADE_STANDARD_ASSERT + setTestName("Magum::Vk::Test::AssertStandardTest"); + #endif +} + +void AssertTest::result() { + Result a = Result::ErrorUnknown; + + Result r = _failAssertResult ? Result::ErrorFragmentedPool : Result::Success; + MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); + + CORRADE_COMPARE(a, Result::Success); +} + +void AssertTest::vkResult() { + VkResult a = VK_ERROR_UNKNOWN; + + VkResult s = _failAssertVkResult ? VK_ERROR_FRAGMENTED_POOL : VK_SUCCESS; + MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = s); + + CORRADE_COMPARE(Result(a), Result::Success); +} + +}}}} + +CORRADE_TEST_MAIN(Magnum::Vk::Test::AssertTest) diff --git a/src/Magnum/Vk/Test/CMakeLists.txt b/src/Magnum/Vk/Test/CMakeLists.txt index 3e8bd4270..fd8563d7e 100644 --- a/src/Magnum/Vk/Test/CMakeLists.txt +++ b/src/Magnum/Vk/Test/CMakeLists.txt @@ -38,6 +38,45 @@ corrade_add_test(VkIntegrationTest IntegrationTest.cpp LIBRARIES MagnumVk) corrade_add_test(VkLayerPropertiesTest LayerPropertiesTest.cpp LIBRARIES MagnumVk) corrade_add_test(VkMemoryTest MemoryTest.cpp LIBRARIES MagnumVk) corrade_add_test(VkResultTest ResultTest.cpp LIBRARIES MagnumVk) + +add_library(VkAssertTestObjects OBJECT AssertTest.cpp) +target_include_directories(VkAssertTestObjects PRIVATE $) +corrade_add_test(VkAssertTest + $ + ${PROJECT_SOURCE_DIR}/src/dummy.cpp + LIBRARIES MagnumVk) +# WILL_FAIL doesn't work for abort() on desktop, test this only on embedded +# then. Oh well. Also the tests could be just one executable added multiple +# 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 + $ + ${PROJECT_SOURCE_DIR}/src/dummy.cpp + ARGUMENTS --fail-on-assert-result true + LIBRARIES MagnumVk) + set_tests_properties(VkAssertTestFailAssertResult PROPERTIES + PASS_REGULAR_EXPRESSION "Call a = r failed with Vk::Result::ErrorFragmentedPool at ") + corrade_add_test(VkAssertTestFailAssertVkResult + $ + ${PROJECT_SOURCE_DIR}/src/dummy.cpp + ARGUMENTS --fail-on-assert-vk-result true + LIBRARIES MagnumVk) + set_tests_properties(VkAssertTestFailAssertVkResult PROPERTIES + PASS_REGULAR_EXPRESSION "Call a = s failed with Vk::Result::ErrorFragmentedPool at ") +endif() + +# The same as above, but using CORRADE_STANDARD_ASSERT +corrade_add_test(VkAssertStandardTest AssertTest.cpp LIBRARIES MagnumVk) +target_compile_definitions(VkAssertStandardTest PRIVATE + "CORRADE_STANDARD_ASSERT") + +corrade_add_test(VkAssertDisabledTest AssertDisabledTest.cpp LIBRARIES MagnumVk) +# The same as above, but using CORRADE_STANDARD_ASSERT and NDEBUG +corrade_add_test(VkAssertStandardDisabledTest AssertDisabledTest.cpp LIBRARIES MagnumVk) +target_compile_definitions(VkAssertStandardDisabledTest PRIVATE + "CORRADE_STANDARD_ASSERT" "NDEBUG") + corrade_add_test(VkVersionTest VersionTest.cpp LIBRARIES MagnumVk) if(BUILD_VK_TESTS) diff --git a/src/Magnum/Vk/Test/ResultTest.cpp b/src/Magnum/Vk/Test/ResultTest.cpp index 2e200ca6c..2e40969eb 100644 --- a/src/Magnum/Vk/Test/ResultTest.cpp +++ b/src/Magnum/Vk/Test/ResultTest.cpp @@ -25,7 +25,6 @@ #include #include -#include #include #include "Magnum/Vk/Result.h" @@ -35,45 +34,14 @@ namespace Magnum { namespace Vk { namespace Test { namespace { struct ResultTest: TestSuite::Tester { explicit ResultTest(); - void assertResult(); - void assertVkResult(); + /* The assert macro is tested separately, as it needs a bunch of extra + handling */ void debug(); - - bool _failAssertResult, _failAssertVkResult; }; -ResultTest::ResultTest(): TestSuite::Tester{TesterConfiguration{}.setSkippedArgumentPrefixes({"fail-on"})} { - addTests({&ResultTest::assertResult, - &ResultTest::assertVkResult, - - &ResultTest::debug}); - - 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") - .parse(arguments().first, arguments().second); - - _failAssertResult = args.value("assert-result"); - _failAssertVkResult = args.value("assert-vk-result"); -} - -void ResultTest::assertResult() { - Result a = Result::ErrorUnknown; - - Result r = _failAssertResult ? Result::ErrorFragmentedPool : Result::Success; - MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); - - CORRADE_COMPARE(a, Result::Success); -} - -void ResultTest::assertVkResult() { - VkResult a = VK_ERROR_UNKNOWN; - - VkResult r = _failAssertVkResult ? VK_ERROR_FRAGMENTED_POOL : VK_SUCCESS; - MAGNUM_VK_INTERNAL_ASSERT_RESULT(a = r); - - CORRADE_COMPARE(Result(a), Result::Success); +ResultTest::ResultTest() { + addTests({&ResultTest::debug}); } void ResultTest::debug() { diff --git a/src/Magnum/Vk/Version.cpp b/src/Magnum/Vk/Version.cpp index d189a5320..b12ad699d 100644 --- a/src/Magnum/Vk/Version.cpp +++ b/src/Magnum/Vk/Version.cpp @@ -29,7 +29,8 @@ #include #include -#include "Magnum/Vk/Result.h" +#include "Magnum/Vk/Assert.h" +#include "Magnum/Vk/Vulkan.h" namespace Magnum { namespace Vk {