mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 17:56:05 +00:00
748023dc32
`[[__noreturn__]]` is now always available, so we can simply use the attribute directly instead of through a macro.
153 lines
9.3 KiB
C++
153 lines
9.3 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef TEST_SUPPORT_ASSERT_MACROS_H
|
|
#define TEST_SUPPORT_ASSERT_MACROS_H
|
|
|
|
// Contains a set of validation macros.
|
|
//
|
|
// Note these test were added after C++20 was well supported by the compilers
|
|
// used. To make the implementation simple the macros require C++20 or newer.
|
|
// It's not expected that existing tests start to use these new macros.
|
|
//
|
|
// These macros are an alternative to using assert. The differences are:
|
|
// - The assert message isn't localized.
|
|
// - It's possible to log additional information. This is useful when the
|
|
// function asserting is a helper function. In these cases the assertion
|
|
// failure contains to little information to find the issue. For example, in
|
|
// the format functions, the really useful information is the actual output,
|
|
// the expected output, and the format string used. These macros allow
|
|
// logging additional arguments.
|
|
|
|
#include "test_macros.h"
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
|
|
// This function prints the given arguments to standard error.
|
|
//
|
|
// Keeping this as a separate function is important since it provides a single point for
|
|
// downstreams to customize how errors are printed on exotic targets, if needed.
|
|
template <class ...Args>
|
|
void test_eprintf(char const* fmt, Args const& ...args) {
|
|
std::fprintf(stderr, fmt, args...);
|
|
}
|
|
|
|
void test_log(const char* condition, const char* file, int line, const char* message) {
|
|
const char* msg = condition ? "Assertion failure: " : "Unconditional failure:";
|
|
test_eprintf("%s%s %s %d\n%s", msg, condition, file, line, message);
|
|
}
|
|
|
|
template <class F>
|
|
void test_log(const char* condition, const char* file, int line, const F& functor) {
|
|
test_eprintf("Assertion failure: %s %s %d\n", condition, file, line);
|
|
functor();
|
|
}
|
|
|
|
template <class Arg>
|
|
[[noreturn]] void test_fail(const char* file, int line, const Arg& arg) {
|
|
test_log("", file, line, arg);
|
|
std::abort();
|
|
}
|
|
|
|
template <class Arg>
|
|
void test_require(bool condition, const char* condition_str, const char* file, int line, const Arg& arg) {
|
|
if (condition)
|
|
return;
|
|
|
|
test_log(condition_str, file, line, arg);
|
|
std::abort();
|
|
}
|
|
|
|
// assert(false) replacement
|
|
// The ARG is either a
|
|
// - c-string or std::string, in which case the string is printed to stderr,
|
|
// - an invocable object, which will be invoked.
|
|
#define TEST_FAIL(ARG) ::test_fail(__FILE__, __LINE__, ARG)
|
|
|
|
// assert replacement.
|
|
// ARG is the same as for TEST_FAIL
|
|
#define TEST_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)
|
|
|
|
// LIBCPP_ASSERT replacement
|
|
//
|
|
// This requirement is only tested when the test suite is used for libc++.
|
|
// This allows checking libc++ specific requirements, for example the error
|
|
// messages of exceptions.
|
|
// ARG is the same as for TEST_FAIL
|
|
#if defined(_LIBCPP_VERSION)
|
|
# define TEST_LIBCPP_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)
|
|
#else
|
|
# define TEST_LIBCPP_REQUIRE(...) /* DO NOTHING */
|
|
#endif
|
|
|
|
// Helper macro to test an expression does not throw any exception.
|
|
#ifndef TEST_HAS_NO_EXCEPTIONS
|
|
# define TEST_DOES_NOT_THROW(EXPR) \
|
|
do { \
|
|
try { \
|
|
static_cast<void>(EXPR); \
|
|
} catch (...) { \
|
|
::test_log(#EXPR, __FILE__, __LINE__, "no exception was expected\n"); \
|
|
::std::abort(); \
|
|
} \
|
|
} while (false) /* */
|
|
|
|
// Helper macro to test an expression throws an exception of the expected type.
|
|
# define TEST_THROWS_TYPE(TYPE, EXPR) \
|
|
do { \
|
|
try { \
|
|
static_cast<void>(EXPR); \
|
|
::test_log(nullptr, \
|
|
__FILE__, \
|
|
__LINE__, \
|
|
"no exception is thrown while an exception of type " #TYPE " was expected\n"); \
|
|
::std::abort(); \
|
|
} catch (const TYPE&) { \
|
|
/* DO NOTHING */ \
|
|
} catch (...) { \
|
|
::test_log(nullptr, \
|
|
__FILE__, \
|
|
__LINE__, \
|
|
"the type of the exception caught differs from the expected type " #TYPE "\n"); \
|
|
::std::abort(); \
|
|
} \
|
|
} while (false) /* */
|
|
|
|
// Helper macro to test an expression throws an exception of the expected type and satisfies a predicate.
|
|
//
|
|
// In order to log additional information the predicate can use log macros.
|
|
// The exception caught is used as argument to the predicate.
|
|
# define TEST_VALIDATE_EXCEPTION(TYPE, PRED, EXPR) \
|
|
do { \
|
|
try { \
|
|
static_cast<void>(EXPR); \
|
|
::test_log(nullptr, \
|
|
__FILE__, \
|
|
__LINE__, \
|
|
"no exception is thrown while an exception of type " #TYPE " was expected\n"); \
|
|
::std::abort(); \
|
|
} catch (const TYPE& EXCEPTION) { \
|
|
PRED(EXCEPTION); \
|
|
} catch (...) { \
|
|
::test_log(nullptr, \
|
|
__FILE__, \
|
|
__LINE__, \
|
|
"the type of the exception caught differs from the expected type " #TYPE "\n"); \
|
|
::std::abort(); \
|
|
} \
|
|
} while (false) /* */
|
|
|
|
#else // TEST_HAS_NO_EXCEPTIONS
|
|
# define TEST_DOES_NOT_THROW(EXPR) static_cast<void>(EXPR);
|
|
# define TEST_THROWS_TYPE(...) /* DO NOTHING */
|
|
# define TEST_VALIDATE_EXCEPTION(...) /* DO NOTHING */
|
|
#endif // TEST_HAS_NO_EXCEPTIONS
|
|
|
|
#endif // TEST_SUPPORT_ASSERT_MACROS_H
|