//======================================================================
//-----------------------------------------------------------------------
/**
 * @file        iutest_switch_assume.hpp
 * @brief       ASSUME フレーバー切り替え ファイル
 *
 * @author      t.shirayanagi
 * @par         copyright
 * Copyright (C) 2013-2016, Takazumi Shirayanagi\n
 * This software is released under the new BSD License,
 * see LICENSE
*/
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_SWITCH_ASSUME_HPP_E22A3162_D581_4F4F_A344_F5D701B21F53_
#define INCG_IRIS_IUTEST_SWITCH_ASSUME_HPP_E22A3162_D581_4F4F_A344_F5D701B21F53_

#if !defined(IUTEST_USE_GTEST)

//======================================================================
// define
#define ASSUME_TRUE     IUTEST_ASSUME_TRUE
#define ASSUME_FALSE    IUTEST_ASSUME_FALSE
#define ASSUME_EQ       IUTEST_ASSUME_EQ
#define ASSUME_NE       IUTEST_ASSUME_NE
#define ASSUME_LT       IUTEST_ASSUME_LT
#define ASSUME_LE       IUTEST_ASSUME_LE
#define ASSUME_GT       IUTEST_ASSUME_GT
#define ASSUME_GE       IUTEST_ASSUME_GE
#define ASSUME_NEAR     IUTEST_ASSUME_NEAR
#define ASSUME_FLOAT_EQ     IUTEST_ASSUME_FLOAT_EQ
#define ASSUME_DOUBLE_EQ    IUTEST_ASSUME_DOUBLE_EQ
#define ASSUME_STREQ        IUTEST_ASSUME_STREQ
#define ASSUME_STRNE        IUTEST_ASSUME_STRNE
#define ASSUME_STRCASEEQ    IUTEST_ASSUME_STRCASEEQ
#define ASSUME_STRCASENE    IUTEST_ASSUME_STRCASENE
#define ASSUME_THROW        IUTEST_ASSUME_THROW
#define ASSUME_NO_THROW     IUTEST_ASSUME_NO_THROW
#define ASSUME_ANY_THROW    IUTEST_ASSUME_ANY_THROW
#define ASSUME_NO_FATAL_FAILURE IUTEST_ASSUME_NO_FATAL_FAILURE

#ifdef IUTEST_OS_WINDOWS
#  define ASSUME_HRESULT_SUCCEEDED  IUTEST_ASSUME_HRESULT_SUCCEEDED
#  define ASSUME_HRESULT_FAILED     IUTEST_ASSUME_HRESULT_FAILED
#endif

#define ASSUME_PRED1    IUTEST_ASSUME_PRED1
#define ASSUME_PRED2    IUTEST_ASSUME_PRED2
#define ASSUME_PRED3    IUTEST_ASSUME_PRED3
#define ASSUME_PRED4    IUTEST_ASSUME_PRED4
#define ASSUME_PRED5    IUTEST_ASSUME_PRED5

#define ASSUME_PRED_FORMAT1 IUTEST_ASSUME_PRED_FORMAT1
#define ASSUME_PRED_FORMAT2 IUTEST_ASSUME_PRED_FORMAT2
#define ASSUME_PRED_FORMAT3 IUTEST_ASSUME_PRED_FORMAT3
#define ASSUME_PRED_FORMAT4 IUTEST_ASSUME_PRED_FORMAT4
#define ASSUME_PRED_FORMAT5 IUTEST_ASSUME_PRED_FORMAT5


#else // !defined(IUTEST_USE_GTEST)

//======================================================================
// undef
#if defined(INCG_IRIS_IUTEST_HPP_)

#undef IUTEST_ASSUME
#undef IUTEST_ASSUME_NOT
#undef IUTEST_ASSUME_TRUE
#undef IUTEST_ASSUME_FALSE
#undef IUTEST_ASSUME_EQ
#undef IUTEST_ASSUME_NE
#undef IUTEST_ASSUME_LT
#undef IUTEST_ASSUME_LE
#undef IUTEST_ASSUME_GT
#undef IUTEST_ASSUME_GE
#undef IUTEST_ASSUME_NEAR
#undef IUTEST_ASSUME_NULL
#undef IUTEST_ASSUME_NOTNULL
#undef IUTEST_ASSUME_SAME
#undef IUTEST_ASSUME_FLOAT_EQ
#undef IUTEST_ASSUME_DOUBLE_EQ
#undef IUTEST_ASSUME_STREQ
#undef IUTEST_ASSUME_STRNE
#undef IUTEST_ASSUME_STRCASEEQ
#undef IUTEST_ASSUME_STRCASENE
#undef IUTEST_ASSUME_THROW
#undef IUTEST_ASSUME_NO_THROW
#undef IUTEST_ASSUME_ANY_THROW
#undef IUTEST_ASSUME_NO_FATAL_FAILURE
#undef IUTEST_ASSUME_PRED_FORMAT1
#undef IUTEST_ASSUME_PRED_FORMAT2
#undef IUTEST_ASSUME_PRED_FORMAT3
#undef IUTEST_ASSUME_PRED_FORMAT4
#undef IUTEST_ASSUME_PRED_FORMAT5
#undef IUTEST_ASSUME_PRED1
#undef IUTEST_ASSUME_PRED2
#undef IUTEST_ASSUME_PRED3
#undef IUTEST_ASSUME_PRED4
#undef IUTEST_ASSUME_PRED5

#ifdef IUTEST_OS_WINDOWS
#undef IUTEST_ASSUME_HRESULT_SUCCEEDED
#undef IUTEST_ASSUME_HRESULT_FAILED
#endif

#undef IUTEST_ASSUME_FAILURE

#endif

//======================================================================
// define
#define GTEST_ASSUME_FAILURE_(message) \
    return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)

#define ASSUME_PRED_FORMAT1(pred_format, v1) \
    GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_ASSUME_FAILURE_)
#define ASSUME_PRED1(pred, v1) \
    GTEST_PRED1_(pred, v1, GTEST_ASSUME_FAILURE_)

#define ASSUME_PRED_FORMAT2(pred_format, v1, v2) \
    GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_ASSUME_FAILURE_)
#define ASSUME_PRED2(pred, v1, v2) \
    GTEST_PRED2_(pred, v1, v2, GTEST_ASSUME_FAILURE_)

#define ASSUME_PRED_FORMAT3(pred_format, v1, v2, v3) \
    GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_ASSUME_FAILURE_)
#define ASSUME_PRED3(pred, v1, v2, v3) \
    GTEST_PRED3_(pred, v1, v2, v3, GTEST_ASSUME_FAILURE_)

#define ASSUME_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
    GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_ASSUME_FAILURE_)
#define ASSUME_PRED4(pred, v1, v2, v3, v4) \
    GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_ASSUME_FAILURE_)

#define ASSUME_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
    GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_ASSUME_FAILURE_)
#define ASSUME_PRED5(pred, v1, v2, v3, v4, v5) \
    GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_ASSUME_FAILURE_)


#define ASSUME_TRUE(condition)  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_ASSUME_FAILURE_)
#define ASSUME_FALSE(condition) GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, GTEST_ASSUME_FAILURE_)

#define ASSUME_EQ(expected, actual) \
    ASSUME_PRED_FORMAT2(::testing::internal:: \
    EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
    expected, actual)
#define ASSUME_NE(expected, actual) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
#define ASSUME_LE(val1, val2) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define ASSUME_LT(val1, val2) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define ASSUME_GE(val1, val2) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define ASSUME_GT(val1, val2) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

#define ASSUME_STREQ(expected, actual) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
#define ASSUME_STRNE(s1, s2) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define ASSUME_STRCASEEQ(expected, actual) \
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
#define ASSUME_STRCASENE(s1, s2)\
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define ASSUME_FLOAT_EQ(expected, actual)\
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
    expected, actual)
#define ASSUME_DOUBLE_EQ(expected, actual)\
    ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
    expected, actual)
#define ASSUME_NEAR(val1, val2, abs_error)\
    ASSUME_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
    val1, val2, abs_error)

#define ASSUME_THROW(statement, expected_exception) \
    GTEST_TEST_THROW_(statement, expected_exception, GTEST_ASSUME_FAILURE_)
#define ASSUME_NO_THROW(statement) \
    GTEST_TEST_NO_THROW_(statement, GTEST_ASSUME_FAILURE_)
#define ASSUME_ANY_THROW(statement) \
    GTEST_TEST_ANY_THROW_(statement, GTEST_ASSUME_FAILURE_)

#define ASSUME_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_ASSUME_FAILURE_)

#define IUTEST_ASSUME(...)                  ASSUME_TRUE(__VA_ARGS__)
#define IUTEST_ASSUME_NOT(...)              ASSUME_FALSE(__VA_ARGS__)
#define IUTEST_ASSUME_TRUE(...)             ASSUME_TRUE(!!(__VA_ARGS__))
#define IUTEST_ASSUME_FALSE(...)            ASSUME_FALSE((__VA_ARGS__))
#define IUTEST_ASSUME_EQ                    ASSUME_EQ
#define IUTEST_ASSUME_NE(expected, actual)  ASSUME_PRED_FORMAT2(    \
                                                ::testing::internal::NeHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, expected, actual)
#define IUTEST_ASSUME_LT                    ASSUME_LT
#define IUTEST_ASSUME_LE                    ASSUME_LE
#define IUTEST_ASSUME_GT                    ASSUME_GT
#define IUTEST_ASSUME_GE                    ASSUME_GE
#define IUTEST_ASSUME_NULL(v)               ASSUME_EQ(NULL, v)
#define IUTEST_ASSUME_NOTNULL(v)            ASSUME_TRUE(NULL != (v))
#define IUTEST_ASSUME_SAME(v1, v2)          ASSUME_PRED_FORMAT2(::testing::internal::CmpHelperSame, v1, v2)
#define IUTEST_ASSUME_NEAR                  ASSUME_NEAR
#define IUTEST_ASSUME_FLOAT_EQ              ASSUME_FLOAT_EQ
#define IUTEST_ASSUME_DOUBLE_EQ             ASSUME_DOUBLE_EQ
#define IUTEST_ASSUME_STREQ                 ASSUME_STREQ
#define IUTEST_ASSUME_STRNE                 ASSUME_STRNE
#define IUTEST_ASSUME_STRCASEEQ             ASSUME_STRCASEEQ
#define IUTEST_ASSUME_STRCASENE             ASSUME_STRCASENE
#define IUTEST_ASSUME_THROW(statement, expected_exception)  ASSUME_THROW((void)(statement), expected_exception)
#define IUTEST_ASSUME_NO_THROW(statement)   ASSUME_NO_THROW((void)(statement))
#define IUTEST_ASSUME_ANY_THROW(statement)  ASSUME_ANY_THROW((void)(statement))
#define IUTEST_ASSUME_NO_FATAL_FAILURE      ASSUME_NO_FATAL_FAILURE

#ifdef GTEST_OS_WINDOWS
# define ASSUME_HRESULT_SUCCEEDED(expr) \
    ASSUME_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
# define ASSUME_HRESULT_FAILED(expr) \
    ASSUME_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

#  define IUTEST_ASSUME_HRESULT_SUCCEEDED   ASSUME_HRESULT_SUCCEEDED
#  define IUTEST_ASSUME_HRESULT_FAILED      ASSUME_HRESULT_FAILED
#endif

#define IUTEST_ASSUME_PRED1 ASSUME_PRED1
#define IUTEST_ASSUME_PRED2 ASSUME_PRED2
#define IUTEST_ASSUME_PRED3 ASSUME_PRED3
#define IUTEST_ASSUME_PRED4 ASSUME_PRED4
#define IUTEST_ASSUME_PRED5 ASSUME_PRED5

#define IUTEST_ASSUME_PRED_FORMAT1  ASSUME_PRED_FORMAT1
#define IUTEST_ASSUME_PRED_FORMAT2  ASSUME_PRED_FORMAT2
#define IUTEST_ASSUME_PRED_FORMAT3  ASSUME_PRED_FORMAT3
#define IUTEST_ASSUME_PRED_FORMAT4  ASSUME_PRED_FORMAT4
#define IUTEST_ASSUME_PRED_FORMAT5  ASSUME_PRED_FORMAT5

#define IUTEST_ASSUME_FAILURE   GTEST_ASSUME_FAILURE_

#endif // !defined(IUTEST_USE_GTEST)

#define ASSUME_NULL     IUTEST_ASSUME_NULL
#define ASSUME_NOTNULL  IUTEST_ASSUME_NOTNULL
#define ASSUME_SAME     IUTEST_ASSUME_SAME

#endif // INCG_IRIS_IUTEST_SWITCH_ASSUME_HPP_E22A3162_D581_4F4F_A344_F5D701B21F53_
