Skip to content

Commit

Permalink
LibTest: Define test expectation macros without copying the input values
Browse files Browse the repository at this point in the history 
Currently, the following test case will actually copy both `a` and `b`
when the test macro is expanded:

    ByteBuffer a = { some large buffer };
    ByteBuffer b = { some other buffer };
    EXPECT_EQ(a, b);

This patch redefines the expectation macros to avoid copying.
  • Loading branch information
@trflynn89 @awesomekling
trflynn89 authored and awesomekling committed Aug 13, 2024
1 parent d57d14f commit f7fcde7
Showing 1 changed file with 127 additions and 85 deletions.
212 changes: 127 additions & 85 deletions Userland/Libraries/LibTest/Macros.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,16 +10,13 @@
#include <AK/Assertions.h>
#include <AK/CheckedFormatString.h>
#include <AK/Math.h>
#include <AK/SourceLocation.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();
Expand All @@ -32,102 +29,147 @@ void enable_reporting();
void disable_reporting();

u64 randomized_runs();

template<typename T>
void expect(T const& expression, StringView expression_string, SourceLocation location = SourceLocation::current())
{
if (!static_cast<bool>(expression)) {
if (is_reporting_enabled())
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT({}) failed", location.filename(), location.line_number(), expression_string);

set_current_test_result(TestResult::Failed);
}
}

template<typename LHS, typename RHS>
void expect_equality(LHS const& lhs, RHS const& rhs, StringView lhs_string, StringView rhs_string, SourceLocation location = SourceLocation::current())
{
if (lhs != rhs) {
if (is_reporting_enabled()) {
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ({}, {}) failed with lhs={} and rhs={}",
location.filename(), location.line_number(), lhs_string, rhs_string,
FormatIfSupported { lhs }, FormatIfSupported { rhs });
}

set_current_test_result(TestResult::Failed);
}
}

#define EXPECT_EQ(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
if (lhs != rhs) { \
if (::Test::is_reporting_enabled()) \
::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); \
} \
template<typename LHS, typename RHS>
void expect_truthy_equality(LHS const& lhs, RHS const& rhs, StringView lhs_string, StringView rhs_string, SourceLocation location = SourceLocation::current())
{
if (static_cast<bool>(lhs) != static_cast<bool>(rhs)) {
if (is_reporting_enabled()) {
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ_TRUTH({}, {}) failed with lhs={} ({}) and rhs={} ({})",
location.filename(), location.line_number(), lhs_string, rhs_string,
FormatIfSupported { lhs }, static_cast<bool>(lhs),
FormatIfSupported { rhs }, static_cast<bool>(rhs));
}

set_current_test_result(TestResult::Failed);
}
}

template<typename LHS, typename RHS>
void expect_equality_with_forced_logging(LHS const& lhs, RHS const& rhs, StringView lhs_string, StringView rhs_string, SourceLocation location = SourceLocation::current())
{
if (lhs != rhs) {
if (is_reporting_enabled()) {
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_EQ({}, {}) failed with lhs={} and rhs={}",
location.filename(), location.line_number(), lhs_string, rhs_string,
lhs, rhs);
}

set_current_test_result(TestResult::Failed);
}
}

template<typename LHS, typename RHS>
void expect_inequality(LHS const& lhs, RHS const& rhs, StringView lhs_string, StringView rhs_string, SourceLocation location = SourceLocation::current())
{
if (lhs == rhs) {
if (is_reporting_enabled()) {
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_NE({}, {}) failed with lhs={} and rhs={}",
location.filename(), location.line_number(), lhs_string, rhs_string,
FormatIfSupported { lhs }, FormatIfSupported { rhs });
}

set_current_test_result(TestResult::Failed);
}
}

template<FloatingPoint LHS, FloatingPoint RHS>
void expect_approximate(LHS lhs, RHS rhs, StringView lhs_string, StringView rhs_string, double tolerance, SourceLocation location = SourceLocation::current())
{
auto diff = static_cast<double>(lhs) - static_cast<double>(rhs);

if (AK::fabs(diff) > tolerance) {
if (is_reporting_enabled()) {
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_APPROXIMATE({}, {}) failed with lhs={} and rhs={}, (lhs-rhs)={}",
location.filename(), location.line_number(), lhs_string, rhs_string,
lhs, rhs, diff);
}

set_current_test_result(TestResult::Failed);
}
}

template<typename T>
bool assume(T const& expression, StringView expression_string, SourceLocation location = SourceLocation::current())
{
if (!static_cast<bool>(expression)) {
if (is_reporting_enabled()) {
warnln("\033[31;1mREJECTED\033[0m: {}:{}: Couldn't generate random value satisfying ASSUME({})",
location.filename(), location.line_number(), expression_string);
}

set_current_test_result(TestResult::Rejected);
return false;
}

return true;
}

}

#define EXPECT(x) \
do { \
::Test::expect(x, #x##sv); \
} 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) { \
if (::Test::is_reporting_enabled()) \
::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); \
} \
#define EXPECT_EQ(a, b) \
do { \
::Test::expect_equality(a, b, #a##sv, #b##sv); \
} 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) { \
if (::Test::is_reporting_enabled()) \
::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); \
} \
#define EXPECT_EQ_TRUTH(a, b) \
do { \
::Test::expect_truthy_equality(a, b, #a##sv, #b##sv); \
} while (false)

#define EXPECT_NE(a, b) \
do { \
auto lhs = (a); \
auto rhs = (b); \
if (lhs == rhs) { \
if (::Test::is_reporting_enabled()) \
::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); \
} \
// 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 { \
::Test::expect_equality_with_forced_logging(a, b, #a##sv, #b##sv); \
} while (false)

#define EXPECT(x) \
do { \
if (!(x)) { \
if (::Test::is_reporting_enabled()) \
::AK::warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT({}) failed", __FILE__, __LINE__, #x); \
::Test::set_current_test_result(::Test::TestResult::Failed); \
} \
#define EXPECT_NE(a, b) \
do { \
::Test::expect_inequality(a, b, #a##sv, #b##sv); \
} 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)) { \
if (::Test::is_reporting_enabled()) \
::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); \
} \
#define EXPECT_APPROXIMATE_WITH_ERROR(a, b, err) \
do { \
::Test::expect_approximate(a, b, #a##sv, #b##sv, err); \
} while (false)

#define EXPECT_APPROXIMATE(a, b) EXPECT_APPROXIMATE_WITH_ERROR(a, b, 0.0000005)

#define REJECT(message) \
do { \
if (::Test::is_reporting_enabled()) \
::AK::warnln("\033[31;1mREJECTED\033[0m: {}:{}: {}", \
__FILE__, __LINE__, #message); \
::Test::set_current_test_result(::Test::TestResult::Rejected); \
} while (false)

#define ASSUME(x) \
do { \
if (!(x)) { \
if (::Test::is_reporting_enabled()) \
::AK::warnln("\033[31;1mREJECTED\033[0m: {}:{}: Couldn't generate random value satisfying ASSUME({})", \
__FILE__, __LINE__, #x); \
::Test::set_current_test_result(::Test::TestResult::Rejected); \
return; \
} \
#define ASSUME(x) \
do { \
if (!::Test::assume(x, #x##sv)) \
return; \
} while (false)

#define FAIL(message) \
Expand Down

0 comments on commit f7fcde7

Please sign in to comment.