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 {