iris unit test internal definition [詳解]

#include "iutest_config.hpp"
#include "../iutest_pred.hpp"
#include "../iutest_package.hpp"

iutest_internal.hpp の依存先関係図:

被依存関係図:

マクロ定義
#define	IUTEST_TEST_(testcase_, testname_, parent_class_, type_id_)

#define	IUTEST_MESSAGE_AT(file_, line_, msg_, result_type_) ::iutest::AssertionHelper(file_, line_, msg_, result_type_) = ::iutest::AssertionHelper::Fixed()

#define	IUTEST_MESSAGE(msg_, result_type_) IUTEST_MESSAGE_AT(__FILE__, __LINE__, msg_, result_type_)

#define	IUTEST_ASSERT_FAILURE(msg) IUTEST_ASSERT_FAILURE_AT(msg, __FILE__, __LINE__)

#define	IUTEST_ASSERT_FAILURE_AT(msg, file, line) return IUTEST_MESSAGE_AT(file, line, msg, ::iutest::TestPartResult::kFatalFailure)

#define	IUTEST_EXPECT_FAILURE(msg) IUTEST_EXPECT_FAILURE_AT(msg, __FILE__, __LINE__)

#define	IUTEST_EXPECT_FAILURE_AT(msg, file, line) IUTEST_MESSAGE_AT(file, line, msg, ::iutest::TestPartResult::kNonFatalFailure)

#define	IUTEST_INFORM_FAILURE(msg) IUTEST_INFORM_FAILURE_AT(msg, __FILE__, __LINE__)

#define	IUTEST_INFORM_FAILURE_AT(msg, file, line) IUTEST_MESSAGE_AT(file, line, msg, ::iutest::TestPartResult::kWarning)

#define	IUTEST_ASSUME_FAILURE(msg) IUTEST_ASSUME_FAILURE_AT(msg, __FILE__, __LINE__)

#define	IUTEST_ASSUME_FAILURE_AT(msg, file, line) return IUTEST_MESSAGE_AT(file, line, msg, ::iutest::TestPartResult::kAssumeFailure)

#define	IUTEST_SKIP_MESSAGE(msg) IUTEST_SKIP_MESSAGE_AT(msg, __FILE__, __LINE__)

#define	IUTEST_SKIP_MESSAGE_AT(msg, file, line) return IUTEST_MESSAGE_AT(file, line, msg, ::iutest::TestPartResult::kSkip)

#define	IUTEST_MAKE_ASSERTIONRESULT_(ar) ar

#define	IUTEST_TEST_ASSERT_(expression, on_failure)

#define	IUTEST_TEST_THROW_(statement, expected_exception, on_failure)

#define	IUTEST_TEST_THROW_VALUE_(statement, expected_exception, expected_exception_value, on_failure, pred_formatter)

#define	IUTEST_TEST_THROW_VALUE_EQ_(statement, expected_exception, expected_exception_value, on_failure)

#define	IUTEST_TEST_THROW_VALUE_NE_(statement, expected_exception, expected_exception_value, on_failure)

#define	IUTEST_TEST_THROW_VALUE_STREQ_(statement, expected_exception, expected_exception_value, on_failure)

#define	IUTEST_TEST_THROW_VALUE_STRCASEEQ_(statement, expected_exception, expected_exception_value, on_failure)

#define	IUTEST_TEST_ANY_THROW_(statement, on_failure)

#define	IUTEST_TEST_NO_THROW_(statement, on_failure)

#define	IUTEST_TEST_BOOLEAN_(expression, text, actual, expected, on_failure)

#define	IUTEST_ASSERT_EXIT(cond)

#define	IUTEST_THROUGH_ANALYSIS_ASSUME_(expr, todo) todo

#define	IUTEST_TEST_EQ(expected, actual, on_failure)

#define	IUTEST_TEST_ALMOST_EQ(expected, actual, on_failure)

#define	IUTEST_TEST_NE(v1, v2, on_failure)

#define	IUTEST_TEST_LE(v1, v2, on_failure)

#define	IUTEST_TEST_LT(v1, v2, on_failure)

#define	IUTEST_TEST_GE(v1, v2, on_failure)

#define	IUTEST_TEST_GT(v1, v2, on_failure)

#define	IUTEST_TEST_TRUE(expr, text, on_failure) IUTEST_TEST_BOOLEAN_( expr, text, false, true, on_failure)

#define	IUTEST_TEST_FALSE(expr, text, on_failure) IUTEST_TEST_BOOLEAN_( !(expr), text, true, false, on_failure)

#define	IUTEST_TEST_FLOAT_EQ(expected, actual, on_failure)

#define	IUTEST_TEST_DOUBLE_EQ(expected, actual, on_failure)

#define	IUTEST_TEST_NEAR(v1, v2, abs_v, on_failure)

#define	IUTEST_TEST_STREQ(expected, actual, on_failure)

#define	IUTEST_TEST_STRNE(v1, v2, on_failure)

#define	IUTEST_TEST_STRCASEEQ(expected, actual, on_failure)

#define	IUTEST_TEST_STRCASENE(v1, v2, on_failure)

#define	IUTEST_TEST_SAME(v1, v2, on_failure)

#define	IUTEST_TEST_NULL(v, on_failure)

#define	IUTEST_TEST_NOTNULL(v, on_failure)

#define	IUTEST_TEST_NO_FAILURE_(statement, on_failure)

#define	IUTEST_TEST_NO_FATAL_FAILURE_(statement, on_failure)

#define	IUTEST_TEST_SKIP()

#define	IUTEST_TEST_COMPILEERROR(e) IUTEST_PRAGMA_MESSAGE("IUTEST_TEST_COMPILEERROR( " #e " )")
	コンパイルエラーチェックタグ


#define	IUTEST_TEST_CLASS_NAME_(testcase_, testname_) IIUT_TEST_CLASS_NAME_I(IIUT_TO_VARNAME_(testcase_), IIUT_TO_VARNAME_(testname_))

#define	IUTEST_TEST_INSTANCE_NAME_(testcase_, testname_) IIUT_TEST_INSTANCE_NAME_I(IIUT_TO_VARNAME_(testcase_), IIUT_TO_VARNAME_(testname_))

#define	IUTEST_ALIAS_TESTNAME_(name_) UNPAREN_(dummy, IUTEST_PP_CAT(iutest_japanese_var, __LINE__), name_)

#define	IUTEST_ALIAS_TESTNAME_F_(name_, var_) UNPAREN_(dummy, var_, name_)

#define	IUTEST_TEST_STRICT_(testcase_, testname_, parent_class_, type_id_)

#define	IUTEST_TEST_F_(testfixture_, testname_) IIUT_TEST_F_A_(IUTEST_TEST_, testfixture_, testname_)


#define	IUTEST_PMZ_TEST_CLASS_NAME_(testcase_, testname_) IIUT_PMZ_TEST_CLASS_NAME_I(IIUT_TO_VARNAME_(testcase_), IIUT_TO_VARNAME_(testname_))


#define	IUTEST_CLASS_INITIALIZE(methodName) static void SetUpTestCase() { methodName(); } static void methodName()

#define	IUTEST_CLASS_CLEANUP(methodName) static void TearDownTestCase() { methodName(); } static void methodName()

#define	IUTEST_METHOD_INITIALIZE(methodName) virtual void SetUp() IUTEST_CXX_OVERRIDE { methodName(); } void methodName()

#define	IUTEST_METHOD_CLEANUP(methodName) virtual void TearDown() IUTEST_CXX_OVERRIDE { methodName(); } void methodName()


#define	IUTEST_TEST_STATICASSERT(e) IUTEST_TEST_COMPILEERROR("static_assert")
	static_assert チェックタグ

詳解

iris unit test internal definition

著者: t.shirayanagi

copyright: Copyright (C) 2011-2020, Takazumi Shirayanagi
This software is released under the new BSD License, see LICENSE

マクロ定義詳解

◆ IUTEST_ASSERT_EXIT

#define IUTEST_ASSERT_EXIT ( cond )

値:

                                                do { if( !(cond) ) {                                                \
                                                IUTEST_MESSAGE(#cond, ::iutest::TestPartResult::kFatalFailure); \
                                                exit(1);                                                        \
                                            } } while(::iutest::detail::AlwaysFalse())

◆ IUTEST_TEST_

#define IUTEST_TEST_	(	testcase_,
		testname_,
		parent_class_,
		type_id_
	)

値:

    class IUTEST_TEST_CLASS_NAME_(testcase_, testname_) : public parent_class_ {            \
    IUTEST_PP_DISALLOW_COPY_AND_ASSIGN(IUTEST_TEST_CLASS_NAME_(testcase_, testname_));      \
        public: IUTEST_TEST_CLASS_NAME_(testcase_, testname_)() {}                          \
        protected: virtual void Body() IUTEST_CXX_OVERRIDE;                                 \
    };                                                                                      \
    ::iutest::detail::TestInstance<IUTEST_TEST_CLASS_NAME_(testcase_, testname_)>           \
    IUTEST_TEST_INSTANCE_NAME_(testcase_, testname_)(                                       \
        IUTEST_CONCAT_PACKAGE_(IIUT_TO_NAME_(testcase_)), IIUT_TO_NAME_STR_(testname_)      \
        , type_id_, parent_class_::SetUpTestCase, parent_class_::TearDownTestCase);         \
    void IUTEST_TEST_CLASS_NAME_(testcase_, testname_)::Body()

◆ IUTEST_TEST_ALMOST_EQ

#define IUTEST_TEST_ALMOST_EQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::backward::AlmostEqHelper<IUTEST_IS_NULLLITERAL(expected)>::Compare \

, expected, actual, on_failure )

◆ IUTEST_TEST_ANY_THROW_

#define IUTEST_TEST_ANY_THROW_	(	statement,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
    if( ::iutest::detail::AlwaysTrue() ) {                                  \
        try {                                                               \
            IIUT_SEH_THROUGH(statement);                                    \
            goto IUTEST_PP_CAT(iutest_label_anythrow, __LINE__);            \
        } catch( ... ) {                                                    \
        }                                                                   \
    } else                                                                  \
        IUTEST_PP_CAT(iutest_label_anythrow, __LINE__):                     \
        on_failure("\nExpected: " #statement " throws an exception.\n  Actual: it doesn's throws.")

◆ IUTEST_TEST_ASSERT_

#define IUTEST_TEST_ASSERT_	(	expression,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                  \
    if( const ::iutest::AssertionResult iutest_ar = IUTEST_MAKE_ASSERTIONRESULT_(expression) )  \
        ;                                           \
    else                                            \
        on_failure(iutest_ar.message())

◆ IUTEST_TEST_BOOLEAN_

#define IUTEST_TEST_BOOLEAN_	(	expression,
		text,
		actual,
		expected,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                              \
    if( const ::iutest::AssertionResult iutest_ar = ::iutest::AssertionResult::Is(expression) ) \
        ;                                                                       \
    else                                                                        \
        on_failure(::iutest::internal::GetBooleanAssertionFailureMessage(       \
            iutest_ar, text, #actual, #expected).c_str() )

◆ IUTEST_TEST_DOUBLE_EQ

#define IUTEST_TEST_DOUBLE_EQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperFloatingPointEQ<double> \

, expected, actual, on_failure )

◆ IUTEST_TEST_EQ

#define IUTEST_TEST_EQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::backward::EqHelper<IUTEST_IS_NULLLITERAL(expected)>::Compare \

, expected, actual, on_failure )

◆ IUTEST_TEST_FLOAT_EQ

#define IUTEST_TEST_FLOAT_EQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperFloatingPointEQ<float> \

, expected, actual, on_failure )

◆ IUTEST_TEST_GE

#define IUTEST_TEST_GE	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperGE \

, v1, v2, on_failure )

◆ IUTEST_TEST_GT

#define IUTEST_TEST_GT	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperGT \

, v1, v2, on_failure )

◆ IUTEST_TEST_LE

#define IUTEST_TEST_LE	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperLE \

, v1, v2, on_failure )

◆ IUTEST_TEST_LT

#define IUTEST_TEST_LT	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperLT \

, v1, v2, on_failure )

◆ IUTEST_TEST_NE

#define IUTEST_TEST_NE	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::backward::NeHelper<IUTEST_IS_NULLLITERAL(v1)>::Compare \

, v1, v2, on_failure )

◆ IUTEST_TEST_NEAR

#define IUTEST_TEST_NEAR	(	v1,
		v2,
		abs_v,
		on_failure
	)

値:

IUTEST_PRED_FORMAT3_( ::iutest::internal::CmpHelperNear \

, v1, v2, abs_v, on_failure )

◆ IUTEST_TEST_NO_FAILURE_

#define IUTEST_TEST_NO_FAILURE_	(	statement,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
    if( ::iutest::detail::AlwaysTrue() ) {                                  \
        ::iutest::detail::NewTestPartResultCheckHelper::Counter<            \
            ::iutest::detail::NewTestPartResultCheckHelper::CondGt<         \
            ::iutest::TestPartResult::kSuccess> > iutest_failure_checker;   \
        IUTEST_SUPPRESS_UNREACHABLE_CODE_WARNING( { (void)0; statement; } ) \
        if( iutest_failure_checker.count() > 0 ) {                          \
            goto IUTEST_PP_CAT(iutest_label_test_no_failure_, __LINE__);    \
        }                                                                   \
    } else                                                                  \
        IUTEST_PP_CAT(iutest_label_test_no_failure_, __LINE__):             \
        on_failure("\nExpected: " #statement " doesn't generate new failure.\n  Actual: it does.")

◆ IUTEST_TEST_NO_FATAL_FAILURE_

#define IUTEST_TEST_NO_FATAL_FAILURE_	(	statement,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
    if( ::iutest::detail::AlwaysTrue() ) {                                  \
        ::iutest::detail::NewTestPartResultCheckHelper::Counter<            \
            ::iutest::detail::NewTestPartResultCheckHelper::CondEq<         \
            ::iutest::TestPartResult::kFatalFailure> > iutest_failure_checker;  \
        IUTEST_SUPPRESS_UNREACHABLE_CODE_WARNING( { (void)0; statement; } ) \
        if( iutest_failure_checker.count() > 0 ) {                          \
            goto IUTEST_PP_CAT(iutest_label_test_no_fatalfailure_, __LINE__);   \
        }                                                                   \
    } else                                                                  \
        IUTEST_PP_CAT(iutest_label_test_no_fatalfailure_, __LINE__):        \
        on_failure("\nExpected: " #statement " doesn't generate new fatal failure.\n  Actual: it does.")

◆ IUTEST_TEST_NO_THROW_

#define IUTEST_TEST_NO_THROW_	(	statement,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
    if( ::iutest::AssertionResult iutest_ar = ::iutest::AssertionSuccess() ) {  \
        try {                                                               \
            IIUT_SEH_THROUGH(statement);                                    \
        } catch( const ::std::exception& e ) {                              \
            iutest_ar << "\nExpected: " #statement " doesn't throw an exception.\n  Actual: it throws. what is \""  \
                << e.what() << "\"";                                        \
            goto IUTEST_PP_CAT(iutest_label_nothrow, __LINE__);             \
        } catch( const char *e ) {                                          \
            iutest_ar << "\nExpected: " #statement " doesn't throw an exception.\n  Actual: it throws. \""  \
                << e << "\"";                                               \
            goto IUTEST_PP_CAT(iutest_label_nothrow, __LINE__);             \
        } catch( ... ) {                                                    \
            iutest_ar << "\nExpected: " #statement " doesn't throw an exception.\n  Actual: it throws.";    \
            goto IUTEST_PP_CAT(iutest_label_nothrow, __LINE__);             \
        }                                                                   \
    } else                                                                  \
        IUTEST_PP_CAT(iutest_label_nothrow, __LINE__):                      \
        on_failure(iutest_ar.message())

◆ IUTEST_TEST_NOTNULL

#define IUTEST_TEST_NOTNULL	(	v,
		on_failure
	)

値:

    IUTEST_THROUGH_ANALYSIS_ASSUME_(v!=IUTEST_NULLPTR       \
        , IUTEST_PRED_FORMAT1_( ::iutest::internal::NullHelper<IUTEST_IS_NULLLITERAL(v)>::CompareNe \
            , v, on_failure ))

◆ IUTEST_TEST_NULL

#define IUTEST_TEST_NULL	(	v,
		on_failure
	)

値:

    IUTEST_THROUGH_ANALYSIS_ASSUME_(v==IUTEST_NULLPTR       \
        , IUTEST_PRED_FORMAT1_( ::iutest::internal::NullHelper<IUTEST_IS_NULLLITERAL(v)>::CompareEq \
            , v, on_failure ))

◆ IUTEST_TEST_SAME

#define IUTEST_TEST_SAME	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperSame \

, v1, v2, on_failure )

◆ IUTEST_TEST_SKIP

#define IUTEST_TEST_SKIP ( )

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_          \
    if( ::iutest::detail::AlwaysTrue() )    \
        IUTEST_SKIP_MESSAGE( ::iutest::UnitTest::SkipTest() ? "Skipped. " : "Skipped. but already failed. " )

◆ IUTEST_TEST_STRCASEEQ

#define IUTEST_TEST_STRCASEEQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperSTRCASEEQ \

, expected, actual, on_failure )

◆ IUTEST_TEST_STRCASENE

#define IUTEST_TEST_STRCASENE	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperSTRCASENE \

, v1, v2, on_failure )

◆ IUTEST_TEST_STREQ

#define IUTEST_TEST_STREQ	(	expected,
		actual,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperSTREQ \

, expected, actual, on_failure )

◆ IUTEST_TEST_STRICT_

#define IUTEST_TEST_STRICT_	(	testcase_,
		testname_,
		parent_class_,
		type_id_
	)

値:

IIUT_CHECK_TESTFIXTURE(testcase_) \

IUTEST_TEST_(testcase_, testname_, parent_class_, type_id_)

◆ IUTEST_TEST_STRNE

#define IUTEST_TEST_STRNE	(	v1,
		v2,
		on_failure
	)

値:

IUTEST_PRED_FORMAT2_( ::iutest::internal::CmpHelperSTRNE \

, v1, v2, on_failure )

◆ IUTEST_TEST_THROW_

#define IUTEST_TEST_THROW_	(	statement,
		expected_exception,
		on_failure
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
    if( const char* msg = "" ) {                                            \
        try {                                                               \
            IUTEST_SUPPRESS_UNREACHABLE_CODE_WARNING(IIUT_SEH_THROUGH(statement));  \
            msg = "\nExpected: " #statement " throws an exception of type " \
                #expected_exception ".\n  Actual: it throws nothing.";      \
            goto IUTEST_PP_CAT(iutest_label_throw, __LINE__);               \
        } catch( expected_exception const& ) {                              \
        } catch( ... ) {                                                    \
            msg = "\nExpected: " #statement " throws an exception of type " \
                #expected_exception ".\n  Actual: it throws a different type.";     \
            goto IUTEST_PP_CAT(iutest_label_throw, __LINE__);               \
        }                                                                   \
    } else                                                                  \
        IUTEST_PP_CAT(iutest_label_throw, __LINE__):                        \
        on_failure(msg)

◆ IUTEST_TEST_THROW_VALUE_

#define IUTEST_TEST_THROW_VALUE_	(	statement,
		expected_exception,
		expected_exception_value,
		on_failure,
		pred_formatter
	)

値:

    IUTEST_AMBIGUOUS_ELSE_BLOCKER_                                                      \
    if( ::iutest::AssertionResult iutest_ar = ::iutest::AssertionSuccess() ) {          \
        try {                                                                           \
            IUTEST_SUPPRESS_UNREACHABLE_CODE_WARNING(IIUT_SEH_THROUGH(statement));      \
            iutest_ar << "\nExpected: " #statement " throws an exception of type "      \
                #expected_exception ".\n  Actual: it throws nothing.";                  \
            goto IUTEST_PP_CAT(iutest_label_throw_value, __LINE__);                     \
        } catch( expected_exception const& e) {                                         \
            if( const ::iutest::AssertionResult ar                                      \
                = pred_formatter("e", #expected_exception_value, e, expected_exception_value) ) {           \
            } else {                                                                    \
                iutest_ar << "\nExpected: " #statement " throws an exception of value\n" << ar.message();   \
                goto IUTEST_PP_CAT(iutest_label_throw_value, __LINE__);                 \
            }                                                                           \
        } catch( ... ) {                                                                \
            iutest_ar << "\nExpected: " #statement " throws an exception of type "      \
                #expected_exception ".\n  Actual: it throws a different type.";         \
            goto IUTEST_PP_CAT(iutest_label_throw_value, __LINE__);                     \
        }                                                                               \
    } else                                                                              \
        IUTEST_PP_CAT(iutest_label_throw_value, __LINE__):                              \
        on_failure(iutest_ar.message())

◆ IUTEST_TEST_THROW_VALUE_EQ_

#define IUTEST_TEST_THROW_VALUE_EQ_	(	statement,
		expected_exception,
		expected_exception_value,
		on_failure
	)

値:

IUTEST_TEST_THROW_VALUE_(statement, expected_exception, expected_exception_value, on_failure \

, ::iutest::internal::backward::EqHelper<IUTEST_IS_NULLLITERAL(expected_exception_value)>::Compare)

◆ IUTEST_TEST_THROW_VALUE_NE_

#define IUTEST_TEST_THROW_VALUE_NE_	(	statement,
		expected_exception,
		expected_exception_value,
		on_failure
	)

値:

IUTEST_TEST_THROW_VALUE_(statement, expected_exception, expected_exception_value, on_failure \

, ::iutest::internal::backward::NeHelper<IUTEST_IS_NULLLITERAL(expected_exception_value)>::Compare)

◆ IUTEST_TEST_THROW_VALUE_STRCASEEQ_

#define IUTEST_TEST_THROW_VALUE_STRCASEEQ_	(	statement,
		expected_exception,
		expected_exception_value,
		on_failure
	)

値:

IUTEST_TEST_THROW_VALUE_(statement, expected_exception, expected_exception_value, on_failure \

, ::iutest::internal::CmpHelperSTRCASEEQ)

◆ IUTEST_TEST_THROW_VALUE_STREQ_

#define IUTEST_TEST_THROW_VALUE_STREQ_	(	statement,
		expected_exception,
		expected_exception_value,
		on_failure
	)

値:

IUTEST_TEST_THROW_VALUE_(statement, expected_exception, expected_exception_value, on_failure \

, ::iutest::internal::CmpHelperSTREQ)