Browse Source

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.
pull/234/head
Vladimír Vondruš 6 years ago
parent
commit
86267f1a78
  1. 83
      src/Magnum/Vk/Assert.h
  2. 1
      src/Magnum/Vk/CMakeLists.txt
  3. 2
      src/Magnum/Vk/CommandBuffer.cpp
  4. 2
      src/Magnum/Vk/CommandPool.cpp
  5. 2
      src/Magnum/Vk/Device.cpp
  6. 2
      src/Magnum/Vk/DeviceProperties.cpp
  7. 2
      src/Magnum/Vk/ExtensionProperties.cpp
  8. 2
      src/Magnum/Vk/Image.cpp
  9. 2
      src/Magnum/Vk/Instance.cpp
  10. 2
      src/Magnum/Vk/LayerProperties.cpp
  11. 2
      src/Magnum/Vk/Memory.cpp
  12. 41
      src/Magnum/Vk/Result.h
  13. 82
      src/Magnum/Vk/Test/AssertDisabledTest.cpp
  14. 84
      src/Magnum/Vk/Test/AssertTest.cpp
  15. 39
      src/Magnum/Vk/Test/CMakeLists.txt
  16. 40
      src/Magnum/Vk/Test/ResultTest.cpp
  17. 3
      src/Magnum/Vk/Version.cpp

83
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š <mosra@centrum.cz>
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 <Corrade/Containers/EnumSet.h>
#include <Corrade/Utility/Assert.h>
#include "Magnum/configure.h"
#if !defined(CORRADE_NO_ASSERT) && !defined(MAGNUM_VK_INTERNAL_ASSERT_RESULT)
#ifndef CORRADE_STANDARD_ASSERT
#include <cstdlib>
#include <Corrade/Utility/Debug.h>
#include "Magnum/Vk/Result.h"
#elif !defined(NDEBUG)
#include <cassert>
#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<void>(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

1
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

2
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 {

2
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 {

2
src/Magnum/Vk/Device.cpp

@ -35,13 +35,13 @@
#include <Corrade/Utility/Arguments.h>
#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"

2
src/Magnum/Vk/DeviceProperties.cpp

@ -33,12 +33,12 @@
#include <Corrade/Utility/Debug.h>
#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"

2
src/Magnum/Vk/ExtensionProperties.cpp

@ -30,8 +30,8 @@
#include <Corrade/Containers/StringView.h>
#include <Corrade/Utility/Assert.h>
#include "Magnum/Vk/Assert.h"
#include "Magnum/Vk/Extensions.h"
#include "Magnum/Vk/Result.h"
#include "Magnum/Vk/Version.h"
namespace Magnum { namespace Vk {

2
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 {

2
src/Magnum/Vk/Instance.cpp

@ -32,10 +32,10 @@
#include <Corrade/Containers/StringView.h>
#include <Corrade/Utility/Arguments.h>
#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"

2
src/Magnum/Vk/LayerProperties.cpp

@ -28,7 +28,7 @@
#include <algorithm>
#include <Corrade/Containers/StringView.h>
#include "Magnum/Vk/Result.h"
#include "Magnum/Vk/Assert.h"
namespace Magnum { namespace Vk {

2
src/Magnum/Vk/Memory.cpp

@ -28,9 +28,9 @@
#include <Corrade/Containers/EnumSet.hpp>
#include <Corrade/Utility/Debug.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 {

41
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 <Corrade/Containers/EnumSet.h>
#include <Corrade/Utility/Assert.h>
#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<void>(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

82
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š <mosra@centrum.cz>
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 <sstream>
#ifndef CORRADE_STANDARD_ASSERT
#define CORRADE_NO_ASSERT
#endif
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#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)

84
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š <mosra@centrum.cz>
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 <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/Arguments.h>
#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<bool>("assert-result");
_failAssertVkResult = args.value<bool>("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)

39
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 $<TARGET_PROPERTY:MagnumVk,INTERFACE_INCLUDE_DIRECTORIES>)
corrade_add_test(VkAssertTest
$<TARGET_OBJECTS:VkAssertTestObjects>
${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
$<TARGET_OBJECTS:VkAssertTestObjects>
${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
$<TARGET_OBJECTS:VkAssertTestObjects>
${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)

40
src/Magnum/Vk/Test/ResultTest.cpp

@ -25,7 +25,6 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/Arguments.h>
#include <Corrade/Utility/DebugStl.h>
#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<bool>("assert-result");
_failAssertVkResult = args.value<bool>("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() {

3
src/Magnum/Vk/Version.cpp

@ -29,7 +29,8 @@
#include <Corrade/Containers/StringView.h>
#include <Corrade/Utility/Debug.h>
#include "Magnum/Vk/Result.h"
#include "Magnum/Vk/Assert.h"
#include "Magnum/Vk/Vulkan.h"
namespace Magnum { namespace Vk {

Loading…
Cancel
Save