mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 08:08:12 +00:00
7e5a3650fe
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.)
142 lines
11 KiB
C++
142 lines
11 KiB
C++
/*
|
|
* 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>
|
|
#include <AK/Math.h>
|
|
#include <LibTest/CrashTest.h>
|
|
#include <LibTest/Randomized/RandomnessSource.h>
|
|
#include <LibTest/TestResult.h>
|
|
|
|
namespace AK {
|
|
template<typename... Parameters>
|
|
void warnln(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&...);
|
|
}
|
|
|
|
namespace Test {
|
|
// 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();
|
|
|
|
Randomized::RandomnessSource& randomness_source();
|
|
void set_randomness_source(Randomized::RandomnessSource);
|
|
}
|
|
|
|
#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 }); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
#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); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
// 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); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
#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 }); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
#define EXPECT(x) \
|
|
do { \
|
|
if (!(x)) { \
|
|
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT({}) failed", __FILE__, __LINE__, #x); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
#define EXPECT_APPROXIMATE_WITH_ERROR(a, b, err) \
|
|
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); \
|
|
if (AK::fabs(expect_close_diff) > (err)) { \
|
|
::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); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} \
|
|
} while (false)
|
|
|
|
#define EXPECT_APPROXIMATE(a, b) EXPECT_APPROXIMATE_WITH_ERROR(a, b, 0.0000005)
|
|
|
|
#define FAIL(message) \
|
|
do { \
|
|
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: {}", __FILE__, __LINE__, message); \
|
|
::Test::set_current_test_result(::Test::TestResult::Failed); \
|
|
} while (false)
|
|
|
|
// 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;
|
|
// });
|
|
#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); \
|
|
} while (false)
|
|
|
|
#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); \
|
|
} while (false)
|
|
|
|
#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); \
|
|
} while (false)
|
|
|
|
#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(); \
|
|
})
|