assert_binary.h File Reference

#include "di/container/iterator/distance.h"
#include "di/format/bounded_format_context.h"
#include "di/format/builtin_formatter/prelude.h"
#include "di/format/concepts/formattable.h"
#include "di/format/to_string.h"
#include "di/function/equal.h"
#include "di/function/equal_or_greater.h"
#include "di/function/equal_or_less.h"
#include "di/function/greater.h"
#include "di/function/less.h"
#include "di/function/not_equal.h"
#include "di/math/functions.h"
#include "di/math/to_unsigned.h"
#include "di/meta/compare.h"
#include "di/util/compile_time_fail.h"
#include "di/util/source_location.h"

Go to the source code of this file.

Namespaces
namespace	di
namespace	di::assert
namespace	di::assert::detail

Macros
#define	DI_ASSERT_EQ(a, b)
#define	DI_ASSERT_APPROX_EQ(a, b)
#define	DI_ASSERT_NOT_EQ(a, b)
#define	DI_ASSERT_LT(a, b)
#define	DI_ASSERT_LT_EQ(a, b)
#define	DI_ASSERT_GT(a, b)
#define	DI_ASSERT_GT_EQ(a, b)
#define	ASSERT_EQ   DI_ASSERT_EQ
#define	ASSERT_APPROX_EQ   DI_ASSERT_APPROX_EQ
#define	ASSERT_NOT_EQ   DI_ASSERT_NOT_EQ
#define	ASSERT_LT   DI_ASSERT_LT
#define	ASSERT_LT_EQ   DI_ASSERT_LT_EQ
#define	ASSERT_GT   DI_ASSERT_GT
#define	ASSERT_GT_EQ   DI_ASSERT_GT_EQ

Functions
template<typename T, typename U>
void	di::assert::detail::binary_assert_fail (char const *expression, T &&a, U &&b, util::SourceLocation loc)
template<typename F, typename T, typename U>
constexpr void	di::assert::detail::binary_assert (F op, char const *expression, T &&a, U &&b, util::SourceLocation loc)

Macro Definition Documentation

ASSERT_APPROX_EQ

#define ASSERT_APPROX_EQ   DI_ASSERT_APPROX_EQ

ASSERT_EQ

#define ASSERT_EQ   DI_ASSERT_EQ

ASSERT_GT

#define ASSERT_GT   DI_ASSERT_GT

ASSERT_GT_EQ

#define ASSERT_GT_EQ   DI_ASSERT_GT_EQ

ASSERT_LT

#define ASSERT_LT   DI_ASSERT_LT

ASSERT_LT_EQ

#define ASSERT_LT_EQ   DI_ASSERT_LT_EQ

ASSERT_NOT_EQ

#define ASSERT_NOT_EQ   DI_ASSERT_NOT_EQ

DI_ASSERT_APPROX_EQ

#define DI_ASSERT_APPROX_EQ	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::approximately_equal, "" #a " ~= " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_EQ

#define DI_ASSERT_EQ	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::equal, "" #a " == " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_GT

#define DI_ASSERT_GT	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::greater, "" #a " > " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_GT_EQ

#define DI_ASSERT_GT_EQ	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::equal_or_greater, "" #a " >= " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_LT

#define DI_ASSERT_LT	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::less, "" #a " < " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_LT_EQ

#define DI_ASSERT_LT_EQ	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::equal_or_less, "" #a " <= " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())

DI_ASSERT_NOT_EQ

#define DI_ASSERT_NOT_EQ	(		a,
			b )

Value:

    ::di::assert::detail::binary_assert(::di::function::not_equal, "" #a " != " #b, (a), (b), \
                                        ::di::util::SourceLocation::current())