Debug.h File Reference

Detailed Description

File for all Debug macros and classes.

Check whether a type implements a certain operator.

Author
Christian Feichtinger
Christian Godenschwager chris.nosp@m.tian.nosp@m..gode.nosp@m.nsch.nosp@m.wager.nosp@m.@fau.nosp@m..de

Some advanced assert macros that print a nice error message on failure.

Examples:

For every macro, you can provide a custom message via an additional argument, e.g.: WALBERLA_ASSERT( false, "Will always fail!" ) or WALBERLA_ASSERT_LESS( 42, 5, "42 is larger than 5!" )

Author
Christoph Schwarzmeier chris.nosp@m.toph.nosp@m..schw.nosp@m.arzm.nosp@m.eier@.nosp@m.fau..nosp@m.de
#include "CheckFunctions.h"
#include <functional>
#include <string>
#include "core/Macros.h"

Namespaces

 walberla
 Storage for detected contacts which can be used to perform actions for all contacts, e.g.
 
 walberla::debug
 

Macros

#define WALBERLA_ASSERT_1(X)   { if( !walberla::debug::check_functions_detail::check ( (X) ) ) { walberla::debug::check_functions_detail::check ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_NULLPTR_1(X)   { if( !walberla::debug::check_functions_detail::check_nullptr ( (X) ) ) { walberla::debug::check_functions_detail::check_nullptr ( (X), #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_NOT_NULLPTR_1(X)   { if( !walberla::debug::check_functions_detail::check_not_nullptr ( (X) ) ) { walberla::debug::check_functions_detail::check_not_nullptr ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_EQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_UNEQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_unequal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_unequal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_float_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_float_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_float_unequal( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_float_unequal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_IDENTICAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_identical ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_identical ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_not_identical( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_not_identical( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_LESS_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_less ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_less ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_GREATER_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_greater ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_greater ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_LESS_EQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_less_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_less_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_GREATER_EQUAL_2(X, Y)   { if( !walberla::debug::check_functions_detail::check_greater_equal( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_greater_equal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }
 
#define WALBERLA_ASSERT_2(X, MSG)   { if( !walberla::debug::check_functions_detail::check ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_NULLPTR_2(X, MSG)   { if( !walberla::debug::check_functions_detail::check_nullptr ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_nullptr ( (X), #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_NOT_NULLPTR_2(X, MSG)   { if( !walberla::debug::check_functions_detail::check_not_nullptr ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_not_nullptr ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_EQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_UNEQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_unequal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_unequal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_float_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_float_unequal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_unequal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_3(X, Y, EPS)   { if( !walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), (EPS) ) ) { walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( ), (EPS) ); } }
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_3(X, Y, EPS)   { if( !walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), (EPS) ) ) { walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( ), (EPS) ); } }
 
#define WALBERLA_ASSERT_IDENTICAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_identical ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_identical ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_not_identical ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_not_identical( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_LESS_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_less ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_less ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_GREATER_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_greater ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_greater ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_LESS_EQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_less_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_less_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_GREATER_EQUAL_3(X, Y, MSG)   { if( !walberla::debug::check_functions_detail::check_greater_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_greater_equal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_4(X, Y, EPS, MSG)   { if( !walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), (EPS) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ), (EPS) ); } }
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_4(X, Y, EPS, MSG)   { if( !walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), (EPS) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ), (EPS) ); } }
 
#define WALBERLA_ASSERT_3(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NULLPTR_3(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NULLPTR_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NULLPTR_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NULLPTR_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_NULLPTR_3(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_NULLPTR_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_NULLPTR_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_NULLPTR_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_EQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_EQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_EQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_EQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_UNEQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_UNEQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_UNEQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_UNEQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_2(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_2(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_IDENTICAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_IDENTICAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_IDENTICAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_IDENTICAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_NOT_IDENTICAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_EQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_EQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_EQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_LESS_EQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_EQUAL_1(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_EQUAL_4(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_EQUAL_5(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT_GREATER_EQUAL_6(...)   THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO
 
#define WALBERLA_ASSERT(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_NULLPTR(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NULLPTR_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_NOT_NULLPTR(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NOT_NULLPTR_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_EQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_EQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_UNEQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_UNEQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_FLOAT_EQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_EQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_UNEQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_IDENTICAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_IDENTICAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_NOT_IDENTICAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NOT_IDENTICAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_LESS(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_LESS_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_GREATER(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_GREATER_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_LESS_EQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_LESS_EQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_GREATER_EQUAL(...)   WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_GREATER_EQUAL_, __VA_ARGS__ )
 
#define WALBERLA_ASSERT_SECTION(condition)
 
#define WALBERLA_DEBUG_SECTION()   if(true)
 

Functions

void walberla::debug::myAssert (const char *const file, const int line)
 

Macro Definition Documentation

◆ WALBERLA_ASSERT

#define WALBERLA_ASSERT (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_1

#define WALBERLA_ASSERT_1 (   X)    { if( !walberla::debug::check_functions_detail::check ( (X) ) ) { walberla::debug::check_functions_detail::check ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_2

#define WALBERLA_ASSERT_2 (   X,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_3

#define WALBERLA_ASSERT_3 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_4

#define WALBERLA_ASSERT_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_5

#define WALBERLA_ASSERT_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_6

#define WALBERLA_ASSERT_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_EQUAL

#define WALBERLA_ASSERT_EQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_EQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_EQUAL_1

#define WALBERLA_ASSERT_EQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_EQUAL_2

#define WALBERLA_ASSERT_EQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_EQUAL_3

#define WALBERLA_ASSERT_EQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_EQUAL_4

#define WALBERLA_ASSERT_EQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_EQUAL_5

#define WALBERLA_ASSERT_EQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_EQUAL_6

#define WALBERLA_ASSERT_EQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL

#define WALBERLA_ASSERT_FLOAT_EQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_EQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_FLOAT_EQUAL_1

#define WALBERLA_ASSERT_FLOAT_EQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_2

#define WALBERLA_ASSERT_FLOAT_EQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_float_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_float_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_FLOAT_EQUAL_3

#define WALBERLA_ASSERT_FLOAT_EQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_float_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_FLOAT_EQUAL_4

#define WALBERLA_ASSERT_FLOAT_EQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_5

#define WALBERLA_ASSERT_FLOAT_EQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_6

#define WALBERLA_ASSERT_FLOAT_EQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_1

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_2

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_2 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_3

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_3 (   X,
  Y,
  EPS 
)    { if( !walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), (EPS) ) ) { walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( ), (EPS) ); } }

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_4

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_4 (   X,
  Y,
  EPS,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), (EPS) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_equal_eps ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ), (EPS) ); } }

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_5

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_6

#define WALBERLA_ASSERT_FLOAT_EQUAL_EPSILON_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL

#define WALBERLA_ASSERT_FLOAT_UNEQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_UNEQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_1

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_2

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_float_unequal( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_float_unequal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_3

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_float_unequal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_unequal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_4

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_5

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_6

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_1

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_2

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_2 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_3

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_3 (   X,
  Y,
  EPS 
)    { if( !walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), (EPS) ) ) { walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( ), (EPS) ); } }

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_4

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_4 (   X,
  Y,
  EPS,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), (EPS) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_float_unequal_eps( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ), (EPS) ); } }

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_5

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_6

#define WALBERLA_ASSERT_FLOAT_UNEQUAL_EPSILON_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER

#define WALBERLA_ASSERT_GREATER (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_GREATER_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_GREATER_1

#define WALBERLA_ASSERT_GREATER_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_2

#define WALBERLA_ASSERT_GREATER_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_greater ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_greater ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_GREATER_3

#define WALBERLA_ASSERT_GREATER_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_greater ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_greater ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_GREATER_4

#define WALBERLA_ASSERT_GREATER_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_5

#define WALBERLA_ASSERT_GREATER_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_6

#define WALBERLA_ASSERT_GREATER_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_EQUAL

#define WALBERLA_ASSERT_GREATER_EQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_GREATER_EQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_GREATER_EQUAL_1

#define WALBERLA_ASSERT_GREATER_EQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_EQUAL_2

#define WALBERLA_ASSERT_GREATER_EQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_greater_equal( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_greater_equal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_GREATER_EQUAL_3

#define WALBERLA_ASSERT_GREATER_EQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_greater_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_greater_equal( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_GREATER_EQUAL_4

#define WALBERLA_ASSERT_GREATER_EQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_EQUAL_5

#define WALBERLA_ASSERT_GREATER_EQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_GREATER_EQUAL_6

#define WALBERLA_ASSERT_GREATER_EQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_IDENTICAL

#define WALBERLA_ASSERT_IDENTICAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_IDENTICAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_IDENTICAL_1

#define WALBERLA_ASSERT_IDENTICAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_IDENTICAL_2

#define WALBERLA_ASSERT_IDENTICAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_identical ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_identical ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_IDENTICAL_3

#define WALBERLA_ASSERT_IDENTICAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_identical ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_identical ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_IDENTICAL_4

#define WALBERLA_ASSERT_IDENTICAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_IDENTICAL_5

#define WALBERLA_ASSERT_IDENTICAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_IDENTICAL_6

#define WALBERLA_ASSERT_IDENTICAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS

#define WALBERLA_ASSERT_LESS (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_LESS_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_LESS_1

#define WALBERLA_ASSERT_LESS_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_2

#define WALBERLA_ASSERT_LESS_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_less ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_less ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_LESS_3

#define WALBERLA_ASSERT_LESS_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_less ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_less ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_LESS_4

#define WALBERLA_ASSERT_LESS_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_5

#define WALBERLA_ASSERT_LESS_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_6

#define WALBERLA_ASSERT_LESS_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_EQUAL

#define WALBERLA_ASSERT_LESS_EQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_LESS_EQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_LESS_EQUAL_1

#define WALBERLA_ASSERT_LESS_EQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_EQUAL_2

#define WALBERLA_ASSERT_LESS_EQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_less_equal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_less_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_LESS_EQUAL_3

#define WALBERLA_ASSERT_LESS_EQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_less_equal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_less_equal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_LESS_EQUAL_4

#define WALBERLA_ASSERT_LESS_EQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_EQUAL_5

#define WALBERLA_ASSERT_LESS_EQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_LESS_EQUAL_6

#define WALBERLA_ASSERT_LESS_EQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_IDENTICAL

#define WALBERLA_ASSERT_NOT_IDENTICAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NOT_IDENTICAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_NOT_IDENTICAL_1

#define WALBERLA_ASSERT_NOT_IDENTICAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_IDENTICAL_2

#define WALBERLA_ASSERT_NOT_IDENTICAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_not_identical( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_not_identical( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_NOT_IDENTICAL_3

#define WALBERLA_ASSERT_NOT_IDENTICAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_not_identical ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_not_identical( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_NOT_IDENTICAL_4

#define WALBERLA_ASSERT_NOT_IDENTICAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_IDENTICAL_5

#define WALBERLA_ASSERT_NOT_IDENTICAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_IDENTICAL_6

#define WALBERLA_ASSERT_NOT_IDENTICAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_NULLPTR

#define WALBERLA_ASSERT_NOT_NULLPTR (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NOT_NULLPTR_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_NOT_NULLPTR_1

#define WALBERLA_ASSERT_NOT_NULLPTR_1 (   X)    { if( !walberla::debug::check_functions_detail::check_not_nullptr ( (X) ) ) { walberla::debug::check_functions_detail::check_not_nullptr ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_NOT_NULLPTR_2

#define WALBERLA_ASSERT_NOT_NULLPTR_2 (   X,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_not_nullptr ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_not_nullptr ( #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_NOT_NULLPTR_3

#define WALBERLA_ASSERT_NOT_NULLPTR_3 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_NULLPTR_4

#define WALBERLA_ASSERT_NOT_NULLPTR_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_NULLPTR_5

#define WALBERLA_ASSERT_NOT_NULLPTR_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NOT_NULLPTR_6

#define WALBERLA_ASSERT_NOT_NULLPTR_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NULLPTR

#define WALBERLA_ASSERT_NULLPTR (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_NULLPTR_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_NULLPTR_1

#define WALBERLA_ASSERT_NULLPTR_1 (   X)    { if( !walberla::debug::check_functions_detail::check_nullptr ( (X) ) ) { walberla::debug::check_functions_detail::check_nullptr ( (X), #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_NULLPTR_2

#define WALBERLA_ASSERT_NULLPTR_2 (   X,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_nullptr ( (X) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_nullptr ( (X), #X, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_NULLPTR_3

#define WALBERLA_ASSERT_NULLPTR_3 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NULLPTR_4

#define WALBERLA_ASSERT_NULLPTR_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NULLPTR_5

#define WALBERLA_ASSERT_NULLPTR_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_NULLPTR_6

#define WALBERLA_ASSERT_NULLPTR_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_SECTION

#define WALBERLA_ASSERT_SECTION (   condition)
Value:
if(true)\
if(const walberla::debug::ConditionalExec COND_EXEC = walberla::debug::ConditionalExec(!(condition),std::bind(walberla::debug::myAssert,__FILE__,__LINE__)))

◆ WALBERLA_ASSERT_UNEQUAL

#define WALBERLA_ASSERT_UNEQUAL (   ...)    WALBERLA_MACRO_OVERLOAD( WALBERLA_ASSERT_UNEQUAL_, __VA_ARGS__ )

◆ WALBERLA_ASSERT_UNEQUAL_1

#define WALBERLA_ASSERT_UNEQUAL_1 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_UNEQUAL_2

#define WALBERLA_ASSERT_UNEQUAL_2 (   X,
 
)    { if( !walberla::debug::check_functions_detail::check_unequal ( (X), (Y) ) ) { walberla::debug::check_functions_detail::check_unequal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler() ); } }

◆ WALBERLA_ASSERT_UNEQUAL_3

#define WALBERLA_ASSERT_UNEQUAL_3 (   X,
  Y,
  MSG 
)    { if( !walberla::debug::check_functions_detail::check_unequal ( (X), (Y) ) ) { std::stringstream _ss_; _ss_ << MSG; walberla::debug::check_functions_detail::check_unequal ( (X), (Y), #X, #Y, __FILE__, __LINE__, walberla::debug::check_functions_detail::ExitHandler( _ss_.str() ) ); } }

◆ WALBERLA_ASSERT_UNEQUAL_4

#define WALBERLA_ASSERT_UNEQUAL_4 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_UNEQUAL_5

#define WALBERLA_ASSERT_UNEQUAL_5 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_ASSERT_UNEQUAL_6

#define WALBERLA_ASSERT_UNEQUAL_6 (   ...)    THIS_IS_SUPPOSED_TO_FAIL___YOU_MADE_AN_ERROR_WHEN_USING_AN_ASSERT_MACRO

◆ WALBERLA_DEBUG_SECTION

#define WALBERLA_DEBUG_SECTION ( )    if(true)
void myAssert(const char *const file, const int line)
Definition: Debug.cpp:33