Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 23:53:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibTest/Macros.h

143 lines
11 KiB
C
Raw Normal View History

AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, Andrew Kaster <akaster@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Assertions.h>
#include <AK/CheckedFormatString.h>
Everywhere: Use AK/Math.h if applicable AK's version should see better inlining behaviors, than the LibM one. We avoid mixed usage for now though. Also clean up some stale math includes and improper floatingpoint usage.
2021-07-17 18:29:28 +02:00
#include <AK/Math.h>
LibTest: Expose new EXPECT_CRASH(..) macro for unit test assertions Utilize the Crash type we imported into LibTest to support testing of crash scenarios when testing all other components.
2021-05-07 04:38:56 -07:00
#include <LibTest/CrashTest.h>
LibTest: Add the RandomnessSource abstraction This will be a foundational part of bootstrapping generators: this is the way they'll get prerecorded values from / record random values into RandomRuns. (Generators don't get in contact with RandomRuns themselves, they just interact with the RandomnessSource.)
2023-10-24 00:35:15 +02:00
#include <LibTest/Randomized/RandomnessSource.h>
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
#include <LibTest/TestResult.h>
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
namespace AK {
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void warnln(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&...);
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
}
namespace Test {
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
// Declare helpers so that we can call them from VERIFY in included headers
// the setter for TestResult is already declared in TestResult.h
TestResult current_test_result();
LibTest: Add the RandomnessSource abstraction This will be a foundational part of bootstrapping generators: this is the way they'll get prerecorded values from / record random values into RandomRuns. (Generators don't get in contact with RandomRuns themselves, they just interact with the RandomnessSource.)
2023-10-24 00:35:15 +02:00
Randomized::RandomnessSource& randomness_source();
void set_randomness_source(Randomized::RandomnessSource);
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
}
#define EXPECT_EQ(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
if (lhs != rhs) { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ({}, {}) failed with lhs={} and rhs={}", __FILE__, __LINE__, #a, #b, FormatIfSupported { lhs }, FormatIfSupported { rhs }); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
} \
} while (false)
LibTest: Introduce a macro to only compare truthiness
2021-10-23 02:49:13 +02:00
#define EXPECT_EQ_TRUTH(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
bool ltruth = static_cast<bool>(lhs); \
bool rtruth = static_cast<bool>(rhs); \
if (ltruth != rtruth) { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ_TRUTH({}, {}) failed with lhs={} ({}) and rhs={} ({})", \
__FILE__, __LINE__, #a, #b, FormatIfSupported { lhs }, ltruth, FormatIfSupported { rhs }, rtruth); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Introduce a macro to only compare truthiness
2021-10-23 02:49:13 +02:00
} \
} while (false)
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
// If you're stuck and `EXPECT_EQ` seems to refuse to print anything useful,
// try this: It'll spit out a nice compiler error telling you why it doesn't print.
#define EXPECT_EQ_FORCE(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
if (lhs != rhs) { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ({}, {}) failed with lhs={} and rhs={}", __FILE__, __LINE__, #a, #b, lhs, rhs); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
} \
} while (false)
LibTest: Add EXPECT_NE(..) test assertion.
2021-04-28 19:53:24 -07:00
#define EXPECT_NE(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
if (lhs == rhs) { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_NE({}, {}) failed with lhs={} and rhs={}", __FILE__, __LINE__, #a, #b, FormatIfSupported { lhs }, FormatIfSupported { rhs }); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Add EXPECT_NE(..) test assertion.
2021-04-28 19:53:24 -07:00
} \
} while (false)
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
#define EXPECT(x) \
do { \
if (!(x)) { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT({}) failed", __FILE__, __LINE__, #x); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
} \
} while (false)
LibTest: Add a EXPECT_APPROXIMATE_WITH_ERROR macro with custom error
2023-04-29 15:15:19 -04:00
#define EXPECT_APPROXIMATE_WITH_ERROR(a, b, err) \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
do { \
auto expect_close_lhs = a; \
auto expect_close_rhs = b; \
auto expect_close_diff = static_cast<double>(expect_close_lhs) - static_cast<double>(expect_close_rhs); \
LibTest: Add a EXPECT_APPROXIMATE_WITH_ERROR macro with custom error
2023-04-29 15:15:19 -04:00
if (AK::fabs(expect_close_diff) > (err)) { \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_APPROXIMATE({}, {})" \
" failed with lhs={}, rhs={}, (lhs-rhs)={}", \
__FILE__, __LINE__, #a, #b, expect_close_lhs, expect_close_rhs, expect_close_diff); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-24 23:53:23 -06:00
} \
} while (false)
LibTest: Add FAIL() macro allow tests to force failure with message.
2021-04-27 02:36:48 -07:00
LibTest: Add a EXPECT_APPROXIMATE_WITH_ERROR macro with custom error
2023-04-29 15:15:19 -04:00
#define EXPECT_APPROXIMATE(a, b) EXPECT_APPROXIMATE_WITH_ERROR(a, b, 0.0000005)
LibTest: Add FAIL() macro allow tests to force failure with message.
2021-04-27 02:36:48 -07:00
#define FAIL(message) \
do { \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: {}", __FILE__, __LINE__, message); \
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Add FAIL() macro allow tests to force failure with message.
2021-04-27 02:36:48 -07:00
} while (false)
LibTest: Expose new EXPECT_CRASH(..) macro for unit test assertions Utilize the Crash type we imported into LibTest to support testing of crash scenarios when testing all other components.
2021-05-07 04:38:56 -07:00
// To use, specify the lambda to execute in a sub process and verify it exits:
// EXPECT_CRASH("This should fail", []{
// return Test::Crash::Failure::DidNotCrash;
// });
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
#define EXPECT_CRASH(test_message, test_func) \
do { \
Test::Crash crash(test_message, test_func); \
if (!crash.run()) \
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Expose new EXPECT_CRASH(..) macro for unit test assertions Utilize the Crash type we imported into LibTest to support testing of crash scenarios when testing all other components.
2021-05-07 04:38:56 -07:00
} while (false)
LibTest: Add `EXPECT_CRASH_WITH_SIGNAL`
2021-12-17 18:12:47 +01:00
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
#define EXPECT_CRASH_WITH_SIGNAL(test_message, signal, test_func) \
do { \
Test::Crash crash(test_message, test_func, (signal)); \
if (!crash.run()) \
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Add `EXPECT_CRASH_WITH_SIGNAL`
2021-12-17 18:12:47 +01:00
} while (false)
LibTest: Add `EXPECT_NO_CRASH`
2021-12-15 00:47:43 +01:00
LibTest: Expand test result bool to a TestResult This will be used in the randomized tests a lot more than it is in the unit tests / benchmarks; randomized tests will run the test function multiple times, check the result and optionally start shrinking the failing input. Generators will also be able to fail, resulting in some of the new TestResult variants.
2023-10-24 00:19:04 +02:00
#define EXPECT_NO_CRASH(test_message, test_func) \
do { \
Test::Crash crash(test_message, test_func, 0); \
if (!crash.run()) \
::Test::set_current_test_result(::Test::TestResult::Failed); \
LibTest: Add `EXPECT_NO_CRASH`
2021-12-15 00:47:43 +01:00
} while (false)
LibTest: Add a `TRY_OR_FAIL` macro This macro has the usual `TRY` semantics, but instead of returning the error, it will let the test fail with the formatted error as the fail message.
2023-04-05 20:23:26 +02:00
#define TRY_OR_FAIL(expression) \
({ \
/* Ignore -Wshadow to allow nesting the macro. */ \
AK_IGNORE_DIAGNOSTIC("-Wshadow", \
auto&& _temporary_result = (expression)); \
static_assert(!::AK::Detail::IsLvalueReference<decltype(_temporary_result.release_value())>, \
"Do not return a reference from a fallible expression"); \
if (_temporary_result.is_error()) [[unlikely]] { \
FAIL(_temporary_result.release_error()); \
return; \
} \
_temporary_result.release_value(); \
})
Reference in a new issue Copy permalink