iutest_defs.hpp

[詳解]

//======================================================================
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//======================================================================
#ifndef INCG_IRIS_IUTEST_DEFS_HPP_839F06DB_E0B6_4E6A_84F2_D99C0A44E06C_
#define INCG_IRIS_IUTEST_DEFS_HPP_839F06DB_E0B6_4E6A_84F2_D99C0A44E06C_
 
//======================================================================
// include
// IWYU pragma: begin_exports
#include "internal/iutest_compiler.hpp"
#include "internal/iutest_pp.hpp"
#include "internal/iutest_stdlib.hpp"
#include "iutest_config.hpp"
#include <stdio.h>
#include <utility>
#include <vector>
#include <algorithm>
#include "internal/iutest_debug.hpp"
// IWYU pragma: end_exports
 
#if IUTEST_HAS_TYPED_TEST_P
#  if IUTEST_TYPED_TEST_P_STRICT
#    include <set>
#  endif
#endif
 
namespace iutest
{
 
//======================================================================
// struct
namespace internal
{
 
typedef void* TypeId;       
 
namespace helper
{
 
//======================================================================
// struct
template<typename T>
struct TestTypeIdHelper { public: static bool _dummy; };
 
template<typename T>bool TestTypeIdHelper<T>::_dummy = false;
 
}   // end of namespace helper
 
//======================================================================
// function
template<typename T>
inline TypeId GetTypeId()
{
    return &(helper::TestTypeIdHelper<T>::_dummy);
}
 
inline IUTEST_CXX_CONSTEXPR TypeId GetTestTypeId()
{
    return 0;
}
 
template<size_t SIZE>
struct TypeWithSize : public detail::type_fit_t<SIZE> {};
 
}   // end of namespace internal
 
//======================================================================
// class
namespace detail
{
 
template<size_t MANT>
struct ieee754_bits_from_mant {};
 
// half float
template<>
struct ieee754_bits_from_mant<11>
{
    enum
    {
          EXP = 5
        , MANT = 10
        , MANT_HIDDEN = 1
    };
};
 
// float
template<>
struct ieee754_bits_from_mant<24>
{
    enum
    {
          EXP = 8
        , MANT = 23
        , MANT_HIDDEN = 1
    };
};
 
// double
template<>
struct ieee754_bits_from_mant<53>
{
    enum
    {
          EXP = 11
        , MANT = 52
        , MANT_HIDDEN = 1
    };
};
 
// 80bit
template<>
struct ieee754_bits_from_mant<64>
{
    enum
    {
          EXP = 15
        , MANT = 64
        , MANT_HIDDEN = 0
    };
};
 
// double double
template<>
struct ieee754_bits_from_mant<106>
{
    enum
    {
          EXP = 22
        , MANT = 104
        , MANT_HIDDEN = 2
    };
};
 
// 128bit
template<>
struct ieee754_bits_from_mant<113>
{
    enum
    {
          EXP = 15
        , MANT = 112
        , MANT_HIDDEN = 1
    };
};
 
template<typename T>
struct ieee754_bits : ieee754_bits_from_mant< ::std::numeric_limits<T>::digits > {};
 
#if IUTEST_HAS_FLOAT128
template<>
struct ieee754_bits<__float128> : ieee754_bits_from_mant<IUTEST_FLT128_MANT_DIG> {};
#endif
 
}   // end of namespace detail
 
template<typename RawType>
class floating_point
{
private:
    typedef floating_point<RawType> _Myt;
    typedef typename detail::type_fit_t<sizeof(RawType)> IntType;
 
public:
    typedef typename IntType::Int  Int;
    typedef typename IntType::UInt UInt;
    typedef RawType Float;
    union FInt
    {
        Int     iv;
        UInt    uv;
        Float   fv;
    };
 
public:
    floating_point()
    {
        m_v.uv = 0;
    }
 
    floating_point(RawType f)   // NOLINT
    {
        m_v.uv = 0;
        m_v.fv = f;
    }
 
    floating_point(const floating_point& rhs)
        : m_v(rhs.m_v)
    {
    }
 
public:
    bool    AlmostEquals(const _Myt& rhs) const
    {
        if( is_nan() || rhs.is_nan() )
        {
            return false;
        }
        return NanSensitiveAlmostEquals(rhs);
    }
 
    bool    NanSensitiveAlmostEquals(const _Myt& rhs) const
    {
        const UInt v1 = norm(enable_bits());
        const UInt v2 = norm(rhs.enable_bits());
        const UInt diff = (v1 > v2) ? v1 - v2 : v2 - v1;
        const UInt kMaxUlps = 4u;
        if( diff <= kMaxUlps )
        {
            return true;
        }
        return false;
    }
 
public:
    bool    AlmostNear(const _Myt& rhs, RawType max_abs_error) const
    {
        if( is_nan() || rhs.is_nan() )
        {
            return false;
        }
IUTEST_PRAGMA_WARN_PUSH()
IUTEST_PRAGMA_WARN_DISABLE_FLOAT_EQUAL()
        if( m_v.fv == rhs.m_v.fv )
        {
            return true;
        }
IUTEST_PRAGMA_WARN_POP()
        _Myt abs = Abs(rhs);
        if( abs.m_v.fv <= max_abs_error )
        {
            return true;
        }
        _Myt abs_error = _Myt(max_abs_error);
        if( abs.AlmostEquals(abs_error) ) {
            return true;
        }
        return false;
    }
 
    bool    NanSensitiveAlmostNear(const _Myt& rhs, RawType max_abs_error) const
    {
        if( is_nan() && rhs.is_nan() )
        {
            return true;
        }
        return AlmostNear(rhs, max_abs_error);
    }
 
public:
    _Myt    Abs(const _Myt& rhs) const
    {
        if( m_v.fv > rhs.m_v.fv )
        {
            return _Myt(m_v.fv - rhs.m_v.fv);
        }
        else
        {
            return _Myt(rhs.m_v.fv - m_v.fv);
        }
    }
public:
    UInt    bits() const { return m_v.uv; }
 
    UInt    enable_bits() const { return m_v.uv & kEnableBitMask; }
 
    RawType raw() const { return m_v.fv; }
 
    UInt    exponent_bits() const { return m_v.uv & kExpMask; }
 
    UInt    fraction_bits() const { return mantissa_bits(); }
 
    UInt    mantissa_bits() const { return m_v.uv & kMantMask; }
 
    UInt    economized_mantissa_bits() const { return m_v.uv & kEconomizedMantMask; }
 
    UInt    sign_bit() const { return m_v.uv & kSignMask; }
 
    bool    is_nan() const { return exponent_bits() == kExpMask && economized_mantissa_bits() != 0; }
 
    bool    is_inf() const { return exponent_bits() == kExpMask && economized_mantissa_bits() == 0; }
 
public:
    static _Myt PINF()
    {
        _Myt f;
        f.m_v.uv = kExpMask | kDefaultMantBitMask;
        return f;
    }
    static _Myt NINF()
    {
        _Myt f = PINF();
        f.m_v.uv |= kSignMask;
        return f;
    }
    static _Myt PNAN()
    {
        _Myt f;
        f.m_v.uv = kExpMask | kDefaultMantBitMask | 1;
        return f;
    }
    static _Myt NNAN()
    {
        _Myt f = PNAN();
        f.m_v.uv |= kSignMask;
        return f;
    }
    static _Myt PQNAN()
    {
        _Myt f;
        f.m_v.uv = ((1 << (kEXP + 1)) - 1);
        f.m_v.uv <<= kMANT - 1;
        f.m_v.uv |= kDefaultMantBitMask;
        return f;
    }
    static _Myt NQNAN()
    {
        _Myt f = PQNAN();
        f.m_v.uv |= kSignMask;
        return f;
    }
 
public:
#if !defined(_MSC_VER) || _MSC_VER >= 1310
    operator RawType () const   { return m_v.fv; }  
#else
    operator float() const  { return m_v.fv; }
    operator double() const { return m_v.fv; }
#endif
    _Myt&   operator = (RawType f)  { m_v.fv = f; return *this; }   
    _Myt&   operator = (const _Myt& rhs) { m_v.fv = rhs.m_v.fv; return *this; }   
 
    bool    operator == (RawType rhs) const { return enable_bits() == _Myt(rhs).enable_bits(); }    
    bool    operator == (const _Myt& rhs) const { return enable_bits() == rhs.enable_bits(); }      
    // bool    operator == (const _Myt& rhs) const { return m_v.uv == rhs.m_v.uv; }    //!< 比較
 
public:
    static const int kEXP;
    static const int kMANT;
    static const int kDIGITS;
 
private:
    static UInt norm(UInt v) { return (v & kSignMask) ? (~v + 1) : (v | kSignMask); }
 
    static const UInt kSignMask;
    static const UInt kExpMask;
    static const UInt kMantMask;
    static const UInt kEconomizedMantMask;
    static const UInt kDefaultMantBitMask;
    static const UInt kEnableBitMask;
 
private:
    FInt m_v;
};
 
template<typename T>
const int floating_point<T>::kEXP = detail::ieee754_bits<T>::EXP;
template<typename T>
const int floating_point<T>::kMANT = detail::ieee754_bits<T>::MANT;
template<typename T>
const int floating_point<T>::kDIGITS = detail::ieee754_bits<T>::MANT + detail::ieee754_bits<T>::MANT_HIDDEN;
 
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kSignMask
    = static_cast<typename floating_point<T>::UInt>(1u) << (kEXP + kMANT);
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kExpMask
    = ((static_cast<typename floating_point<T>::UInt>(1u)
        << floating_point<T>::kEXP) - 1) << floating_point<T>::kMANT;
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kMantMask
    = ((static_cast<typename floating_point<T>::UInt>(1u) << floating_point<T>::kMANT) - 1);
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kEconomizedMantMask
    = ((static_cast<typename floating_point<T>::UInt>(1u) << (floating_point<T>::kDIGITS - 1)) - 1);
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kDefaultMantBitMask
    = (static_cast<typename floating_point<T>::UInt>(1u) << (floating_point<T>::kDIGITS - 1));
template<typename T>
const typename floating_point<T>::UInt floating_point<T>::kEnableBitMask
    = floating_point<T>::kSignMask | floating_point<T>::kExpMask | floating_point<T>::kMantMask;
 
// googletest compat
 
namespace internal
{
 
template<typename T>
class FloatingPoint : public floating_point<T>
{
public:
    explicit FloatingPoint(const T& rhs) : floating_point<T>(rhs) {}
};
 
typedef FloatingPoint<float> Float;
typedef FloatingPoint<double> Double;
 
#if IUTEST_HAS_LONG_DOUBLE
typedef FloatingPoint<long double> LongDouble;
#endif
#if IUTEST_HAS_FLOAT128
typedef FloatingPoint<__float128> Float128;
#endif
 
}   // end of namespace internal
 
//======================================================================
// typedef
typedef detail::type_fit_t<1>::Int  Int8;   
typedef detail::type_fit_t<1>::UInt UInt8;  
typedef detail::type_fit_t<2>::Int  Int16;  
typedef detail::type_fit_t<2>::UInt UInt16; 
typedef detail::type_fit_t<4>::Int  Int32;  
typedef detail::type_fit_t<4>::UInt UInt32; 
typedef detail::type_fit_t<8>::Int  Int64;  
typedef detail::type_fit_t<8>::UInt UInt64; 
 
#if IUTEST_HAS_CXX11 && IUTEST_HAS_CXX_HDR_CSTDINT
typedef ::std::intmax_t     iu_off_t;
typedef ::std::uintmax_t    iu_uint_max_t;
#else
typedef Int64               iu_off_t;
typedef UInt64              iu_uint_max_t;
#endif
 
#if IUTEST_HAS_CXX11 && IUTEST_HAS_CXX_HDR_CSTDINT
typedef ::std::uintptr_t                                iu_uintptr_t;
#else
typedef detail::type_fit_t<sizeof(ptrdiff_t)>::UInt     iu_uintptr_t;
#endif
 
typedef internal::TypeId TestTypeId;    
 
typedef void (*SetUpMethod)();      
typedef void (*TearDownMethod)();   
 
typedef detail::type_least_t<8>::UInt   TimeInMillisec; 
typedef detail::type_least_t<8>::Int    BiggestInt;     
 
}   // end of namespace iutest
 
/*
#if IUTEST_HAS_ATTRIBUTE_DEPRECATED
namespace iutest {
namespace detail
{
 
template<typename T>
struct type_check_t { static const int IUTEST_ATTRIBUTE_DEPRECATED_ value = 0; };
 
#if IUTEST_HAS_RVALUE_REFS
template<typename T>
int type_check(T&& x) { return 0; }
#else
template<typename T>
int type_check(const T& x) { return 0; }
#endif
 
}   // end of namespace detail
}   // end of namespace iutest
 
#if defined(_MSC_VER)
#  if IUTEST_HAS_DECLTYPE
#    define IUTEST_CHECK_TYPE(x)    (void)::iutest::detail::type_check_t< decltype(x) >::value
#  endif
#else
#  define IUTEST_CHECK_TYPE(x)      ::iutest::detail::type_check(x)
#endif
 
#if !defined(IUTEST_CHECK_TYPE)
#  define IUTEST_CHECK_TYPE(x)      (void)0
#endif
 
#endif
*/
 
#endif // INCG_IRIS_IUTEST_DEFS_HPP_839F06DB_E0B6_4E6A_84F2_D99C0A44E06C_