iutest.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_HPP_
#define INCG_IRIS_IUTEST_HPP_
 
//======================================================================
// include
// IWYU pragma: begin_exports
#include "iutest_ver.hpp"
#include "iutest_core.hpp"
#include "iutest_param_tests.hpp"
#include "iutest_typed_tests.hpp"
#include "iutest_prod.hpp"
#include "iutest_expression_assertion.hpp"
#include "iutest_matcher.hpp"
#include "iutest_static_assertion.hpp"
#include "iutest_ignore.hpp"
#include "listener/iutest_default_printer.hpp"
#include "listener/iutest_stderr_xml_generator.hpp"
#include "listener/iutest_streaming_listener.hpp"
 
#if defined(__AFX_H__)
#include "internal/iutest_mfc.hpp"
#endif
// IWYU pragma: end_exports
 
//======================================================================
// define
#define IUTEST_TEST(testcase_, testname_)       IUTEST_TEST_STRICT_(testcase_, testname_    \
                                                    , ::iutest::Test, ::iutest::internal::GetTestTypeId())
 
#define IUTEST(testcase_, testname_)            IUTEST_TEST(testcase_, testname_)
 
#define IUTEST_F(testfixture_, testname_)       IUTEST_TEST_F_(testfixture_, testname_)
 
#if IUTEST_HAS_PARAM_METHOD_TEST
 
#define IUTEST_PMZ(testcase_, testname_, method_, ...)  IIUT_TEST_PMZ_(testcase_, testname_     \
                                                            , method_, ::iutest::Test           \
                                                            , ::iutest::internal::GetTestTypeId(), __VA_ARGS__)
 
#define IUTEST_PMZ_F(testfixture_, testname_, method_, ...) IIUT_TEST_PMZ_(testfixture_, testname_  \
                                                                , method_, testfixture_             \
                                                                , ::iutest::internal::GetTypeId< testfixture_ >(), __VA_ARGS__)
 
#endif
 
#if IUTEST_HAS_TESTNAME_ALIAS
 
#define IUTEST_ALIAS_TESTNAME(testname_)                        IUTEST_ALIAS_TESTNAME_(testname_)
 
#define IUTEST_ALIAS_TESTNAME_F(testcasename_, testfixture_)    IUTEST_ALIAS_TESTNAME_F_(testcasename_, testfixture_)
 
#if IUTEST_HAS_TESTNAME_ALIAS_JP
 
#define IUTEST_JAPANESE_NAME(testname_)                         IUTEST_ALIAS_TESTNAME(testname_)
 
#define IUTEST_JAPANESE_NAME_F(testcasename_, testfixture_)     IUTEST_ALIAS_TESTNAME_F(testcasename_, testfixture_)
 
#endif
 
#endif
 
#define IUTEST_INIT(argc_, argv_)               ::iutest::InitIrisUnitTest(argc_, argv_)
 
#define IUTEST_RUN_ALL_TESTS()                  ::iutest::UnitTestSource::GetInstance().Run()
 
 
#define IUTEST_SCOPED_TRACE(msg)                IIUT_SCOPED_MESSAGE(msg)
 
#ifndef IUTEST_SUCCEED
#  define IUTEST_SUCCEED()                      IIUT_SUCCEED()
#endif
 
#ifndef IUTEST_FAIL
#  define IUTEST_FAIL()                         IIUT_FAIL()
#endif
 
#ifndef IUTEST_ADD_FAILURE
#  define IUTEST_ADD_FAILURE()                  IIUT_ADD_FAILURE()
#endif
 
#ifndef IUTEST_ADD_FAILURE_AT
#  define IUTEST_ADD_FAILURE_AT(file, line)     IIUT_ADD_FAILURE_AT(file, line)
#endif
 
#ifndef IUTEST_SKIP
#  define IUTEST_SKIP()                         IUTEST_TEST_SKIP()
#endif
 
#ifndef IUTEST_ASSERT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT(...)                      IUTEST_TEST_EXPRESSION_((__VA_ARGS__), true, IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT(expression)               IUTEST_TEST_EXPRESSION_(expression, true, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_NOT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_NOT(...)                  IUTEST_TEST_EXPRESSION_((__VA_ARGS__), false, IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_NOT(expression)           IUTEST_TEST_EXPRESSION_(expression, false, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#if IUTEST_HAS_MATCHERS
 
#ifndef IUTEST_ASSERT_THAT
#  define IUTEST_ASSERT_THAT(actual, matcher)       IUTEST_TEST_THAT(actual, matcher, IUTEST_ASSERT_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_ASSERT_EQ
#  define IUTEST_ASSERT_EQ(expected, actual)        IUTEST_TEST_EQ(expected, actual, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_ALMOST_EQ
#  define IUTEST_ASSERT_ALMOST_EQ(expected, actual) IUTEST_TEST_ALMOST_EQ(expected, actual, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_NE
#  define IUTEST_ASSERT_NE(v1, v2)                  IUTEST_TEST_NE(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_LE
#  define IUTEST_ASSERT_LE(v1, v2)                  IUTEST_TEST_LE(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_LT
#  define IUTEST_ASSERT_LT(v1, v2)                  IUTEST_TEST_LT(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_GE
#  define IUTEST_ASSERT_GE(v1, v2)                  IUTEST_TEST_GE(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_GT
#  define IUTEST_ASSERT_GT(v1, v2)                  IUTEST_TEST_GT(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_TRUE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_TRUE(...)                 IUTEST_TEST_TRUE((__VA_ARGS__), #__VA_ARGS__, IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_TRUE(v)                   IUTEST_TEST_TRUE(v, #v, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_FALSE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_FALSE(...)                IUTEST_TEST_FALSE((__VA_ARGS__), #__VA_ARGS__, IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_FALSE(v)                  IUTEST_TEST_FALSE(v, #v, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_NULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_NULL(...)                 IUTEST_TEST_NULL((__VA_ARGS__), IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_NULL(v)                   IUTEST_TEST_NULL(v, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_NOTNULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_NOTNULL(...)              IUTEST_TEST_NOTNULL((__VA_ARGS__), IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_NOTNULL(v)                IUTEST_TEST_NOTNULL(v, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_SAME
#  define IUTEST_ASSERT_SAME(v1, v2)                IUTEST_TEST_SAME(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_FLOAT_EQ
#  define IUTEST_ASSERT_FLOAT_EQ(expected, actual)  IUTEST_TEST_FLOAT_EQ(expected, actual, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_DOUBLE_EQ
#  define IUTEST_ASSERT_DOUBLE_EQ(expected, actual) IUTEST_TEST_DOUBLE_EQ(expected, actual, IUTEST_ASSERT_FAILURE)
#endif
 
#if IUTEST_HAS_LONG_DOUBLE
 
#ifndef IUTEST_ASSERT_LONG_DOUBLE_EQ
#  define IUTEST_ASSERT_LONG_DOUBLE_EQ(expected, actual)    \
    IUTEST_TEST_LONG_DOUBLE_EQ(expected, actual, IUTEST_ASSERT_FAILURE)
#endif
#endif
 
#ifndef IUTEST_ASSERT_NEAR
#  define IUTEST_ASSERT_NEAR(v1, v2, abs_v)         IUTEST_TEST_NEAR(v1, v2, abs_v, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_STREQ
#  define IUTEST_ASSERT_STREQ(expected_str, actual_str) \
    IUTEST_TEST_STREQ(expected_str, actual_str, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_STRNE
#  define IUTEST_ASSERT_STRNE(v1, v2)               IUTEST_TEST_STRNE(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_STRCASEEQ
#  define IUTEST_ASSERT_STRCASEEQ(expected_str, actual_str) \
    IUTEST_TEST_STRCASEEQ(expected_str, actual_str, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_STRCASENE
#  define IUTEST_ASSERT_STRCASENE(v1, v2)           IUTEST_TEST_STRCASENE(v1, v2, IUTEST_ASSERT_FAILURE)
#endif
 
#if defined(IUTEST_OS_WINDOWS)
 
#ifndef IUTEST_ASSERT_HRESULT_SUCCEEDED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_HRESULT_SUCCEEDED(...)    IUTEST_TEST_HRESULT_SUCCEEDED((__VA_ARGS__), IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_HRESULT_SUCCEEDED(hr)     IUTEST_TEST_HRESULT_SUCCEEDED(hr, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSERT_HRESULT_FAILED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSERT_HRESULT_FAILED(...)       IUTEST_TEST_HRESULT_FAILED((__VA_ARGS__), IUTEST_ASSERT_FAILURE)
#  else
#    define IUTEST_ASSERT_HRESULT_FAILED(hr)        IUTEST_TEST_HRESULT_FAILED(hr, IUTEST_ASSERT_FAILURE)
#  endif
#endif
 
#endif
 
#if IUTEST_HAS_EXCEPTIONS
 
#ifndef IUTEST_ASSERT_THROW
#  define IUTEST_ASSERT_THROW(statement, expected_exception)    \
    IUTEST_TEST_THROW_(statement, expected_exception, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_THROW_VALUE_EQ
#  define IUTEST_ASSERT_THROW_VALUE_EQ(statement, expected_exception, expected_value)   \
    IUTEST_TEST_THROW_VALUE_EQ_(statement, expected_exception, expected_value, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_THROW_VALUE_NE
#  define IUTEST_ASSERT_THROW_VALUE_NE(statement, expected_exception, v)    \
    IUTEST_TEST_THROW_VALUE_NE_(statement, expected_exception, v, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_THROW_VALUE_STREQ
#  define IUTEST_ASSERT_THROW_VALUE_STREQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STREQ_(statement, expected_exception, expected_str, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_THROW_VALUE_STRCASEEQ
#  define IUTEST_ASSERT_THROW_VALUE_STRCASEEQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STRCASEEQ_(statement, expected_exception, expected_str, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_ANY_THROW
#  define IUTEST_ASSERT_ANY_THROW(statement)        IUTEST_TEST_ANY_THROW_(statement, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_NO_THROW
#  define IUTEST_ASSERT_NO_THROW(statement)         IUTEST_TEST_NO_THROW_(statement, IUTEST_ASSERT_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_ASSERT_NO_FAILURE
#  define IUTEST_ASSERT_NO_FAILURE(statement)       IUTEST_TEST_NO_FAILURE_(statement, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_NO_FATAL_FAILURE
#  define IUTEST_ASSERT_NO_FATAL_FAILURE(statement) IUTEST_TEST_NO_FATAL_FAILURE_(statement, IUTEST_ASSERT_FAILURE)
#endif
 
#ifndef IUTEST_ASSERT_FAIL
#  define IUTEST_ASSERT_FAIL()                      IIUT_FAIL()
#endif
 
#ifndef IUTEST_EXPECT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT(...)                      IUTEST_TEST_EXPRESSION_((__VA_ARGS__), true, IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT(expression)               IUTEST_TEST_EXPRESSION_(expression, true, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_NOT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_NOT(...)                  IUTEST_TEST_EXPRESSION_((__VA_ARGS__), false, IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_NOT(expression)           IUTEST_TEST_EXPRESSION_(expression, false, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#if IUTEST_HAS_MATCHERS
 
#ifndef IUTEST_EXPECT_THAT
#  define IUTEST_EXPECT_THAT(actual, matcher)       IUTEST_TEST_THAT(actual, matcher, IUTEST_EXPECT_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_EXPECT_EQ
#  define IUTEST_EXPECT_EQ(expected, actual)        IUTEST_TEST_EQ(expected, actual, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_ALMOST_EQ
#  define IUTEST_EXPECT_ALMOST_EQ(expected, actual) IUTEST_TEST_ALMOST_EQ(expected, actual, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_NE
#  define IUTEST_EXPECT_NE(v1, v2)                  IUTEST_TEST_NE(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_LE
#  define IUTEST_EXPECT_LE(v1, v2)                  IUTEST_TEST_LE(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_LT
#  define IUTEST_EXPECT_LT(v1, v2)                  IUTEST_TEST_LT(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_GE
#  define IUTEST_EXPECT_GE(v1, v2)                  IUTEST_TEST_GE(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_GT
#  define IUTEST_EXPECT_GT(v1, v2)                  IUTEST_TEST_GT(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_TRUE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_TRUE(...)                 IUTEST_TEST_TRUE((__VA_ARGS__), #__VA_ARGS__, IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_TRUE(v)                   IUTEST_TEST_TRUE(v, #v, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_FALSE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_FALSE(...)                IUTEST_TEST_FALSE((__VA_ARGS__), #__VA_ARGS__, IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_FALSE(v)                  IUTEST_TEST_FALSE(v, #v, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_NULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_NULL(...)                 IUTEST_TEST_NULL((__VA_ARGS__), IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_NULL(v)                   IUTEST_TEST_NULL(v, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_NOTNULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_NOTNULL(...)              IUTEST_TEST_NOTNULL((__VA_ARGS__), IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_NOTNULL(v)                IUTEST_TEST_NOTNULL(v, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_SAME
#  define IUTEST_EXPECT_SAME(v1, v2)                IUTEST_TEST_SAME(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_FLOAT_EQ
#  define IUTEST_EXPECT_FLOAT_EQ(expected, actual)  IUTEST_TEST_FLOAT_EQ(expected, actual, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_DOUBLE_EQ
#  define IUTEST_EXPECT_DOUBLE_EQ(expected, actual) IUTEST_TEST_DOUBLE_EQ(expected, actual, IUTEST_EXPECT_FAILURE)
#endif
 
#if IUTEST_HAS_LONG_DOUBLE
 
#ifndef IUTEST_EXPECT_LONG_DOUBLE_EQ
#  define IUTEST_EXPECT_LONG_DOUBLE_EQ(expected, actual)    \
    IUTEST_TEST_LONG_DOUBLE_EQ(expected, actual, IUTEST_EXPECT_FAILURE)
#endif
#endif
 
#ifndef IUTEST_EXPECT_NEAR
#  define IUTEST_EXPECT_NEAR(v1, v2, abs_v)         IUTEST_TEST_NEAR(v1, v2, abs_v, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_STREQ
#  define IUTEST_EXPECT_STREQ(expected_str, actual_str) \
    IUTEST_TEST_STREQ(expected_str, actual_str, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_STRNE
#  define   IUTEST_EXPECT_STRNE(v1, v2)             IUTEST_TEST_STRNE(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_STRCASEEQ
#  define   IUTEST_EXPECT_STRCASEEQ(expected_str, actual_str)   \
    IUTEST_TEST_STRCASEEQ(expected_str, actual_str, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_STRCASENE
#  define   IUTEST_EXPECT_STRCASENE(v1, v2)         IUTEST_TEST_STRCASENE(v1, v2, IUTEST_EXPECT_FAILURE)
#endif
 
#if defined(IUTEST_OS_WINDOWS)
 
#ifndef IUTEST_EXPECT_HRESULT_SUCCEEDED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_HRESULT_SUCCEEDED(...)    IUTEST_TEST_HRESULT_SUCCEEDED((__VA_ARGS__), IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_HRESULT_SUCCEEDED(hr)     IUTEST_TEST_HRESULT_SUCCEEDED(hr, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_EXPECT_HRESULT_FAILED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_EXPECT_HRESULT_FAILED(...)       IUTEST_TEST_HRESULT_FAILED((__VA_ARGS__), IUTEST_EXPECT_FAILURE)
#  else
#    define IUTEST_EXPECT_HRESULT_FAILED(hr)        IUTEST_TEST_HRESULT_FAILED(hr, IUTEST_EXPECT_FAILURE)
#  endif
#endif
 
#endif
 
#if IUTEST_HAS_EXCEPTIONS
 
#ifndef IUTEST_EXPECT_THROW
#  define IUTEST_EXPECT_THROW(statement, expected_exception)    \
    IUTEST_TEST_THROW_(statement, expected_exception, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_THROW_VALUE_EQ
#  define IUTEST_EXPECT_THROW_VALUE_EQ(statement, expected_exception, expected_value)   \
    IUTEST_TEST_THROW_VALUE_EQ_(statement, expected_exception, expected_value, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_THROW_VALUE_NE
#  define IUTEST_EXPECT_THROW_VALUE_NE(statement, expected_exception, v)    \
    IUTEST_TEST_THROW_VALUE_NE_(statement, expected_exception, v, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_THROW_VALUE_STREQ
#  define IUTEST_EXPECT_THROW_VALUE_STREQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STREQ_(statement, expected_exception, expected_str, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_THROW_VALUE_STRCASEEQ
#  define IUTEST_EXPECT_THROW_VALUE_STRCASEEQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STRCASEEQ_(statement, expected_exception, expected_str, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_ANY_THROW
#  define IUTEST_EXPECT_ANY_THROW(statement)        IUTEST_TEST_ANY_THROW_(statement, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_NO_THROW
#  define IUTEST_EXPECT_NO_THROW(statement)         IUTEST_TEST_NO_THROW_(statement, IUTEST_EXPECT_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_EXPECT_NO_FAILURE
#  define IUTEST_EXPECT_NO_FAILURE(statement)       IUTEST_TEST_NO_FAILURE_(statement, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_NO_FATAL_FAILURE
#  define IUTEST_EXPECT_NO_FATAL_FAILURE(statement) IUTEST_TEST_NO_FATAL_FAILURE_(statement, IUTEST_EXPECT_FAILURE)
#endif
 
#ifndef IUTEST_EXPECT_FAIL
#  define IUTEST_EXPECT_FAIL()                      IIUT_ADD_FAILURE()
#endif
 
#ifndef IUTEST_EXPECT_FAIL_AT
#  define IUTEST_EXPECT_FAIL_AT(file, line)         IIUT_ADD_FAILURE_AT(file, line)
#endif
 
 
#ifndef IUTEST_INFORM
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM(...)                      IUTEST_TEST_EXPRESSION_((__VA_ARGS__), true, IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM(expression)               IUTEST_TEST_EXPRESSION_(expression, true, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_NOT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_NOT(...)                  IUTEST_TEST_EXPRESSION_((__VA_ARGS__), false, IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_NOT(expression)           IUTEST_TEST_EXPRESSION_(expression, false, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#if IUTEST_HAS_MATCHERS
 
#ifndef IUTEST_INFORM_THAT
#  define IUTEST_INFORM_THAT(actual, matcher)       IUTEST_TEST_THAT(actual, matcher, IUTEST_INFORM_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_INFORM_EQ
#  define   IUTEST_INFORM_EQ(expected, actual)      IUTEST_TEST_EQ(expected, actual, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_ALMOST_EQ
#  define IUTEST_INFORM_ALMOST_EQ(expected, actual) IUTEST_TEST_ALMOST_EQ(expected, actual, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_NE
#  define IUTEST_INFORM_NE(v1, v2)                  IUTEST_TEST_NE(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_LE
#  define IUTEST_INFORM_LE(v1, v2)                  IUTEST_TEST_LE(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_LT
#  define IUTEST_INFORM_LT(v1, v2)                  IUTEST_TEST_LT(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_GE
#  define IUTEST_INFORM_GE(v1, v2)                  IUTEST_TEST_GE(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_GT
#  define IUTEST_INFORM_GT(v1, v2)                  IUTEST_TEST_GT(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_TRUE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_TRUE(...)                 IUTEST_TEST_TRUE((__VA_ARGS__), #__VA_ARGS__, IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_TRUE(v)                   IUTEST_TEST_TRUE(v, #v, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_FALSE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_FALSE(...)                IUTEST_TEST_FALSE((__VA_ARGS__), #__VA_ARGS__, IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_FALSE(v)                  IUTEST_TEST_FALSE(v, #v, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_NULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_NULL(...)                 IUTEST_TEST_NULL((__VA_ARGS__), IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_NULL(v)                   IUTEST_TEST_NULL(v, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_NOTNULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_NOTNULL(...)              IUTEST_TEST_NOTNULL((__VA_ARGS__), IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_NOTNULL(v)                IUTEST_TEST_NOTNULL(v, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_SAME
#  define IUTEST_INFORM_SAME(v1, v2)                IUTEST_TEST_SAME(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_FLOAT_EQ
#  define IUTEST_INFORM_FLOAT_EQ(expected, actual)  IUTEST_TEST_FLOAT_EQ(expected, actual, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_DOUBLE_EQ
#  define IUTEST_INFORM_DOUBLE_EQ(expected, actual) IUTEST_TEST_DOUBLE_EQ(expected, actual, IUTEST_INFORM_FAILURE)
#endif
 
#if IUTEST_HAS_LONG_DOUBLE
 
#ifndef IUTEST_INFORM_LONG_DOUBLE_EQ
#  define IUTEST_INFORM_LONG_DOUBLE_EQ(expected, actual)    \
    IUTEST_TEST_LONG_DOUBLE_EQ(expected, actual, IUTEST_INFORM_FAILURE)
#endif
#endif
 
#ifndef IUTEST_INFORM_NEAR
#  define IUTEST_INFORM_NEAR(v1, v2, abs_v)         IUTEST_TEST_NEAR(v1, v2, abs_v, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_STREQ
#  define IUTEST_INFORM_STREQ(expected_str, actual_str) \
    IUTEST_TEST_STREQ(expected_str, actual_str, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_STRNE
#  define IUTEST_INFORM_STRNE(v1, v2)               IUTEST_TEST_STRNE(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_STRCASEEQ
#  define IUTEST_INFORM_STRCASEEQ(expected_str, actual_str) \
    IUTEST_TEST_STRCASEEQ(expected_str, actual_str, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_STRCASENE
#  define IUTEST_INFORM_STRCASENE(v1, v2)           IUTEST_TEST_STRCASENE(v1, v2, IUTEST_INFORM_FAILURE)
#endif
 
#if defined(IUTEST_OS_WINDOWS)
 
#ifndef IUTEST_INFORM_HRESULT_SUCCEEDED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_HRESULT_SUCCEEDED(...)    IUTEST_TEST_HRESULT_SUCCEEDED((__VA_ARGS__), IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_HRESULT_SUCCEEDED(hr)     IUTEST_TEST_HRESULT_SUCCEEDED(hr, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_INFORM_HRESULT_FAILED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_INFORM_HRESULT_FAILED(...)       IUTEST_TEST_HRESULT_FAILED((__VA_ARGS__), IUTEST_INFORM_FAILURE)
#  else
#    define IUTEST_INFORM_HRESULT_FAILED(hr)        IUTEST_TEST_HRESULT_FAILED(hr, IUTEST_INFORM_FAILURE)
#  endif
#endif
 
#endif
 
#if IUTEST_HAS_EXCEPTIONS
 
#ifndef IUTEST_INFORM_THROW
#  define IUTEST_INFORM_THROW(statement, expected_exception)    \
    IUTEST_TEST_THROW_(statement, expected_exception, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_THROW_VALUE_EQ
#  define IUTEST_INFORM_THROW_VALUE_EQ(statement, expected_exception, expected_value)   \
    IUTEST_TEST_THROW_VALUE_EQ_(statement, expected_exception, expected_value, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_THROW_VALUE_NE
#  define IUTEST_INFORM_THROW_VALUE_NE(statement, expected_exception, v)    \
    IUTEST_TEST_THROW_VALUE_NE_(statement, expected_exception, v, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_THROW_VALUE_STREQ
#  define IUTEST_INFORM_THROW_VALUE_STREQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STREQ_(statement, expected_exception, expected_str, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_THROW_VALUE_STRCASEEQ
#  define IUTEST_INFORM_THROW_VALUE_STRCASEEQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STRCASEEQ_(statement, expected_exception, expected_str, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_ANY_THROW
#  define IUTEST_INFORM_ANY_THROW(statement)        IUTEST_TEST_ANY_THROW_(statement, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_NO_THROW
#  define IUTEST_INFORM_NO_THROW(statement)         IUTEST_TEST_NO_THROW_(statement, IUTEST_INFORM_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_INFORM_NO_FAILURE
#  define IUTEST_INFORM_NO_FAILURE(statement)       IUTEST_TEST_NO_FAILURE_(statement, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_INFORM_NO_FATAL_FAILURE
#  define IUTEST_INFORM_NO_FATAL_FAILURE(statement) IUTEST_TEST_NO_FATAL_FAILURE_(statement, IUTEST_INFORM_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME(...)                      IUTEST_TEST_EXPRESSION_((__VA_ARGS__), true, IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME(expression)               IUTEST_TEST_EXPRESSION_(expression, true, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_NOT
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_NOT(...)                  IUTEST_TEST_EXPRESSION_((__VA_ARGS__), false, IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_NOT(expression)           IUTEST_TEST_EXPRESSION_(expression, false, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#if IUTEST_HAS_MATCHERS
 
#ifndef IUTEST_ASSUME_THAT
#  define IUTEST_ASSUME_THAT(actual, matcher)       IUTEST_TEST_THAT(actual, matcher, IUTEST_ASSUME_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_ASSUME_EQ
#  define IUTEST_ASSUME_EQ(expected, actual)        IUTEST_TEST_EQ(expected, actual, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_ALMOST_EQ
#  define IUTEST_ASSUME_ALMOST_EQ(expected, actual) IUTEST_TEST_ALMOST_EQ(expected, actual, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_NE
#  define IUTEST_ASSUME_NE(v1, v2)                  IUTEST_TEST_NE(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_LE
#  define   IUTEST_ASSUME_LE(v1, v2)                IUTEST_TEST_LE(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_LT
#  define IUTEST_ASSUME_LT(v1, v2)                  IUTEST_TEST_LT(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_GE
#  define IUTEST_ASSUME_GE(v1, v2)                  IUTEST_TEST_GE(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_GT
#  define IUTEST_ASSUME_GT(v1, v2)                  IUTEST_TEST_GT(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_TRUE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_TRUE(...)                 IUTEST_TEST_TRUE((__VA_ARGS__), #__VA_ARGS__, IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_TRUE(v)                   IUTEST_TEST_TRUE(v, #v, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_FALSE
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_FALSE(...)                IUTEST_TEST_FALSE((__VA_ARGS__), #__VA_ARGS__, IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_FALSE(v)                  IUTEST_TEST_FALSE(v, #v, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_NULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_NULL(...)                 IUTEST_TEST_NULL((__VA_ARGS__), IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_NULL(v)                   IUTEST_TEST_NULL(v, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_NOTNULL
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_NOTNULL(...)              IUTEST_TEST_NOTNULL((__VA_ARGS__), IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_NOTNULL(v)                IUTEST_TEST_NOTNULL(v, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_SAME
#  define IUTEST_ASSUME_SAME(v1, v2)                IUTEST_TEST_SAME(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_FLOAT_EQ
#  define IUTEST_ASSUME_FLOAT_EQ(expected, actual)  IUTEST_TEST_FLOAT_EQ(expected, actual, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_DOUBLE_EQ
#  define IUTEST_ASSUME_DOUBLE_EQ(expected, actual) IUTEST_TEST_DOUBLE_EQ(expected, actual, IUTEST_ASSUME_FAILURE)
#endif
 
#if IUTEST_HAS_LONG_DOUBLE
 
#ifndef IUTEST_ASSUME_LONG_DOUBLE_EQ
#  define IUTEST_ASSUME_LONG_DOUBLE_EQ(expected, actual)    \
    IUTEST_TEST_LONG_DOUBLE_EQ(expected, actual, IUTEST_ASSUME_FAILURE)
#endif
#endif
 
#ifndef IUTEST_ASSUME_NEAR
#  define IUTEST_ASSUME_NEAR(v1, v2, abs_v)         IUTEST_TEST_NEAR(v1, v2, abs_v, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_STREQ
#  define IUTEST_ASSUME_STREQ(expected_str, actual_str) \
    IUTEST_TEST_STREQ(expected_str, actual_str, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_STRNE
#  define IUTEST_ASSUME_STRNE(v1, v2)               IUTEST_TEST_STRNE(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_STRCASEEQ
#  define IUTEST_ASSUME_STRCASEEQ(expected_str, actual_str) \
    IUTEST_TEST_STRCASEEQ(expected_str, actual_str, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_STRCASENE
#  define IUTEST_ASSUME_STRCASENE(v1, v2)           IUTEST_TEST_STRCASENE(v1, v2, IUTEST_ASSUME_FAILURE)
#endif
 
#if defined(IUTEST_OS_WINDOWS)
 
#ifndef IUTEST_ASSUME_HRESULT_SUCCEEDED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_HRESULT_SUCCEEDED(...)    IUTEST_TEST_HRESULT_SUCCEEDED((__VA_ARGS__), IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_HRESULT_SUCCEEDED(hr)     IUTEST_TEST_HRESULT_SUCCEEDED(hr, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#ifndef IUTEST_ASSUME_HRESULT_FAILED
#  ifndef IUTEST_NO_VARIADIC_MACROS
#    define IUTEST_ASSUME_HRESULT_FAILED(...)       IUTEST_TEST_HRESULT_FAILED((__VA_ARGS__), IUTEST_ASSUME_FAILURE)
#  else
#    define IUTEST_ASSUME_HRESULT_FAILED(hr)        IUTEST_TEST_HRESULT_FAILED(hr, IUTEST_ASSUME_FAILURE)
#  endif
#endif
 
#endif
 
#if IUTEST_HAS_EXCEPTIONS
 
#ifndef IUTEST_ASSUME_THROW
#  define IUTEST_ASSUME_THROW(statement, expected_exception)    \
    IUTEST_TEST_THROW_(statement, expected_exception, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_THROW_VALUE_EQ
#  define IUTEST_ASSUME_THROW_VALUE_EQ(statement, expected_exception, expected_value)   \
    IUTEST_TEST_THROW_VALUE_EQ_(statement, expected_exception, expected_value, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_THROW_VALUE_NE
#  define IUTEST_ASSUME_THROW_VALUE_NE(statement, expected_exception, v)    \
    IUTEST_TEST_THROW_VALUE_NE_(statement, expected_exception, v, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_THROW_VALUE_STREQ
#  define IUTEST_ASSUME_THROW_VALUE_STREQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STREQ_(statement, expected_exception, expected_str, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_THROW_VALUE_STRCASEEQ
#  define IUTEST_ASSUME_THROW_VALUE_STRCASEEQ(statement, expected_exception, expected_str)  \
    IUTEST_TEST_THROW_VALUE_STRCASEEQ_(statement, expected_exception, expected_str, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_ANY_THROW
#  define IUTEST_ASSUME_ANY_THROW(statement)        IUTEST_TEST_ANY_THROW_(statement, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_NO_THROW
#  define IUTEST_ASSUME_NO_THROW(statement)         IUTEST_TEST_NO_THROW_(statement, IUTEST_ASSUME_FAILURE)
#endif
 
#endif
 
#ifndef IUTEST_ASSUME_NO_FAILURE
#  define IUTEST_ASSUME_NO_FAILURE(statement)       IUTEST_TEST_NO_FAILURE_(statement, IUTEST_ASSUME_FAILURE)
#endif
 
#ifndef IUTEST_ASSUME_NO_FATAL_FAILURE
#  define IUTEST_ASSUME_NO_FATAL_FAILURE(statement) IUTEST_TEST_NO_FATAL_FAILURE_(statement, IUTEST_ASSUME_FAILURE)
#endif
 
namespace iutest
{
 
//======================================================================
// class
class UnitTestSource
{
public:
    static UnitTestSource& GetInstance() { static UnitTestSource inst; return inst; }
 
private:
    UnitTestSource()
    {
#if defined(_IUTEST_DEBUG)
        detail::iuDebugInitialize();
#else
        IUTEST_UNUSED_VAR(&detail::iuDebugInitialize);
        IUTEST_UNUSED_VAR(&detail::iuDebugBreakAlloc);
#endif
        TestEnv::event_listeners().set_default_result_printer(new DefaultResultPrintListener());
    }
 
public:
    ~UnitTestSource()
    {
        TestEnv::event_listeners().set_default_result_printer(NULL);
        TestEnv::event_listeners().set_default_xml_generator(NULL);
    }
 
public:
    void Initialize()
    {
        UnitTest::instance().Initialize();
    }
 
    int Run()
    {
        SetUpDefaultListener();
        return UnitTest::instance().Run();
    }
 
private:
    void SetUpDefaultListener()
    {
        if( TestEnv::has_output_option() )
        {
            do
            {
#if defined(__WANDBOX__)
                if( StderrXmlGeneratorListener::SetUp() )
                {
                    break;
                }
                if( StderrJunitXmlGeneratorListener::SetUp() )
                {
                    break;
                }
#else
                if( DefaultXmlGeneratorListener::SetUp() )
                {
                    break;
                }
                if( JunitXmlGeneratorListener::SetUp() )
                {
                    break;
                }
#endif
                IUTEST_LOG_(WARNING) << "unrecognized output format \"" << TestEnv::get_output_option() << "\" ignored.";
            } while( detail::AlwaysFalse() );
        }
 
#if IUTEST_HAS_STREAM_RESULT
        StreamResultListener::SetUp();
#endif
    }
};
 
//======================================================================
// function
namespace detail
{
 
template<typename T>
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, T argv)
{
    UnitTestSource::GetInstance().Initialize();
    TestEnv::ParseCommandLine(pargc, argv);
    TestEnv::LoadFlagFile();
}
 
}   // end of namespace detail
 
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, char** argv)      { detail::InitIrisUnitTest(pargc, argv); }
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, wchar_t** argv)   { detail::InitIrisUnitTest(pargc, argv); }      
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, const char** argv)    { detail::InitIrisUnitTest(pargc, argv); }  
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, const wchar_t** argv) { detail::InitIrisUnitTest(pargc, argv); }  
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest() { detail::InitIrisUnitTest<char**>(NULL, NULL); }   
 
#if IUTEST_HAS_NULLPTR
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(int* pargc, ::std::nullptr_t) { detail::InitIrisUnitTest<char**>(pargc, NULL); }  
#endif
 
template<typename CharType>
inline void IUTEST_ATTRIBUTE_UNUSED_ InitIrisUnitTest(::std::vector< ::std::basic_string<CharType> >& argv)
{
    UnitTestSource::GetInstance().Initialize();
    TestEnv::ParseCommandLine(argv);
    TestEnv::LoadFlagFile();
}
 
inline Environment* IUTEST_ATTRIBUTE_UNUSED_ AddGlobalTestEnvironment(Environment* env)
{
    return TestEnv::AddGlobalTestEnvironment(env);
}
 
}   // end of namespace iutest
 
#if defined(IUTEST_USE_GTEST)
#  include "gtest/iutest_switch.hpp"
#endif
 
#include "iutest_util.hpp"
 
#if defined(IUTEST_USE_MAIN)
#  include "internal/iutest_default_main.hpp"
#endif
 
#endif // INCG_IRIS_IUTEST_HPP_