type_traits_test.cpp

stl的源码

#include <algorithm>
#include <vector>
#include <string>

#include "cppunit/cppunit_proxy.h"

#if defined (_STLP_USE_NAMESPACES)
using namespace std;
#endif

//
// TestCase class
//
class TypeTraitsTest : public CPPUNIT_NS::TestCase
{
  CPPUNIT_TEST_SUITE(TypeTraitsTest);
#if !defined (STLPORT)
  CPPUNIT_IGNORE;
#endif
  CPPUNIT_TEST(manips);
  CPPUNIT_TEST(integer);
  CPPUNIT_TEST(rational);
  CPPUNIT_TEST(pointer_type);
#if defined (STLPORT) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
  CPPUNIT_IGNORE;
#endif
  CPPUNIT_TEST(reference_type);
#if defined (STLPORT)
  CPPUNIT_STOP_IGNORE;
#endif
  CPPUNIT_TEST(both_pointer_type);
  CPPUNIT_TEST(ok_to_use_memcpy);
  CPPUNIT_TEST(ok_to_use_memmove);
  CPPUNIT_TEST(trivial_destructor);
  CPPUNIT_TEST(is_POD);
  CPPUNIT_TEST(stlport_class);
  CPPUNIT_TEST_SUITE_END();

protected:
  void manips();
  void integer();
  void rational();
  void pointer_type();
  void reference_type();
  void both_pointer_type();
  void ok_to_use_memcpy();
  void ok_to_use_memmove();
  void trivial_destructor();
  void is_POD();
  void stlport_class();
};

CPPUNIT_TEST_SUITE_REGISTRATION(TypeTraitsTest);

#if defined (STLPORT)

#  if defined (__GNUC__) && defined (_STLP_USE_NAMESPACES)
// libstdc++ sometimes exposed its own __true_type type in global
// namespace resulting in an ambiguity.
#    define __true_type std::__true_type
#    define __false_type std::__false_type
#  endif

int type_to_value(__true_type)
{ return 1; }
int type_to_value(__false_type)
{ return 0; }

int* int_pointer;
int const* int_const_pointer;
int volatile* int_volatile_pointer;
int const volatile* int_const_volatile_pointer;
int int_val = 0;
int const int_const_val = 0;
int volatile int_volatile_val = 0;
int & int_ref = int_val;
int const& int_const_ref = int_val;
int const volatile& int_const_volatile_ref = int_val;

//A type that represent any type:
struct any_type
{
  //Dummy operations to forbid to compilers with intrinsic
  //type traits support to consider this type as a POD.
  any_type() : m_data(1) {}
  any_type(const any_type&) : m_data(2) {}
  any_type& operator = (const any_type&)
  { m_data = 3; return *this; }
  ~any_type() { m_data = 0; }

  size_t m_data;
};

any_type any;
any_type* any_pointer;
any_type const* any_const_pointer;
any_type volatile* any_volatile_pointer;
any_type const volatile* any_const_volatile_pointer;

//A type that represent any pod type
struct any_pod_type
{};

#  if defined (_STLP_USE_BOOST_SUPPORT)
//Mandatory for compilers without without partial template specialization.
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(any_pod_type)
#  endif

any_pod_type any_pod;
any_pod_type* any_pod_pointer;
any_pod_type const* any_pod_const_pointer;
any_pod_type volatile* any_pod_volatile_pointer;
any_pod_type const volatile* any_pod_const_volatile_pointer;

#  if defined (_STLP_USE_NAMESPACES)
namespace std {
#  endif
  _STLP_TEMPLATE_NULL
  struct __type_traits<any_pod_type> {
    typedef __true_type has_trivial_default_constructor;
    typedef __true_type has_trivial_copy_constructor;
    typedef __true_type has_trivial_assignment_operator;
    typedef __true_type has_trivial_destructor;
    typedef __true_type is_POD_type;
  };
#  if defined (_STLP_USE_NAMESPACES)
}
#  endif

struct base
{};
struct derived : public base
{};

//
// tests implementation
//
template <typename _Src, typename _Dst>
int is_convertible(_Src, _Dst) {
#  if !defined(__BORLANDC__)
  typedef typename _IsConvertible<_Src, _Dst>::_Ret _Ret;
#  else
  enum { _Is = _IsConvertible<_Src, _Dst>::value };
  typedef typename __bool2type<_Is>::_Ret _Ret;
#  endif
  return type_to_value(_Ret());
}

template <typename _Src, typename _Dst>
int is_cv_convertible(_Src, _Dst) {
#  if !defined(__BORLANDC__)
  typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret;
#  else
  enum { _Is = _IsCVConvertible<_Src, _Dst>::value };
  typedef typename __bool2type<_Is>::_Ret _Ret;
#  endif
  return type_to_value(_Ret());
}
#endif

void TypeTraitsTest::manips()
{
#if defined (STLPORT)
  {
    typedef __bool2type<0>::_Ret _ZeroRet;
    CPPUNIT_ASSERT( type_to_value(_ZeroRet()) == 0 );
    typedef __bool2type<1>::_Ret _OneRet;
    CPPUNIT_ASSERT( type_to_value(_OneRet()) == 1 );
    typedef __bool2type<65456873>::_Ret _AnyRet;
    CPPUNIT_ASSERT( type_to_value(_AnyRet()) == 1 );
  }

  {
    CPPUNIT_ASSERT( __type2bool<__true_type>::_Ret == 1 );
    CPPUNIT_ASSERT( __type2bool<__false_type>::_Ret == 0 );
    CPPUNIT_ASSERT( __type2bool<any_type>::_Ret == 1 );
  }

  {
    typedef _Not<__true_type>::_Ret _NotTrueRet;
    CPPUNIT_ASSERT( type_to_value(_NotTrueRet()) == 0 );
    typedef _Not<__false_type>::_Ret _NotFalseRet;
    CPPUNIT_ASSERT( type_to_value(_NotFalseRet()) == 1 );
  }

  {
    typedef _Land2<__true_type, __true_type>::_Ret _TrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueRet()) == 1 );
    typedef _Land2<__true_type, __false_type>::_Ret _TrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseRet()) == 0 );
    typedef _Land2<__false_type, __true_type>::_Ret _FalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueRet()) == 0 );
    typedef _Land2<__false_type, __false_type>::_Ret _FalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseRet()) == 0 );
  }

  {
    typedef _Land3<__true_type, __true_type, __true_type>::_Ret _TrueTrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueTrueRet()) == 1 );
    typedef _Land3<__true_type, __true_type, __false_type>::_Ret _TrueTrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueFalseRet()) == 0 );
    typedef _Land3<__true_type, __false_type, __true_type>::_Ret _TrueFalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseTrueRet()) == 0 );
    typedef _Land3<__true_type, __false_type, __false_type>::_Ret _TrueFalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseFalseRet()) == 0 );
    typedef _Land3<__false_type, __true_type, __true_type>::_Ret _FalseTrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueTrueRet()) == 0 );
    typedef _Land3<__false_type, __true_type, __false_type>::_Ret _FalseTrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueFalseRet()) == 0 );
    typedef _Land3<__false_type, __false_type, __true_type>::_Ret _FalseFalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseTrueRet()) == 0 );
    typedef _Land3<__false_type, __false_type, __false_type>::_Ret _FalseFalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseFalseRet()) == 0 );
  }

  {
    typedef _Lor2<__true_type, __true_type>::_Ret _TrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueRet()) == 1 );
    typedef _Lor2<__true_type, __false_type>::_Ret _TrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseRet()) == 1 );
    typedef _Lor2<__false_type, __true_type>::_Ret _FalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueRet()) == 1 );
    typedef _Lor2<__false_type, __false_type>::_Ret _FalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseRet()) == 0 );
  }

  {
    typedef _Lor3<__true_type, __true_type, __true_type>::_Ret _TrueTrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueTrueRet()) == 1 );
    typedef _Lor3<__true_type, __true_type, __false_type>::_Ret _TrueTrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueTrueFalseRet()) == 1 );
    typedef _Lor3<__true_type, __false_type, __true_type>::_Ret _TrueFalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseTrueRet()) == 1 );
    typedef _Lor3<__true_type, __false_type, __false_type>::_Ret _TrueFalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_TrueFalseFalseRet()) == 1 );
    typedef _Lor3<__false_type, __true_type, __true_type>::_Ret _FalseTrueTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueTrueRet()) == 1 );
    typedef _Lor3<__false_type, __true_type, __false_type>::_Ret _FalseTrueFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseTrueFalseRet()) == 1 );
    typedef _Lor3<__false_type, __false_type, __true_type>::_Ret _FalseFalseTrueRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseTrueRet()) == 1 );
    typedef _Lor3<__false_type, __false_type, __false_type>::_Ret _FalseFalseFalseRet;
    CPPUNIT_ASSERT( type_to_value(_FalseFalseFalseRet()) == 0 );
  }

  {
    typedef __select<1, __true_type, __false_type>::_Ret _SelectFirstRet;
    CPPUNIT_ASSERT( type_to_value(_SelectFirstRet()) == 1 );
    typedef __select<0, __true_type, __false_type>::_Ret _SelectSecondRet;
    CPPUNIT_ASSERT( type_to_value(_SelectSecondRet()) == 0 );
#  if defined (__BORLANDC__)
    typedef __selectT<__true_type, __true_type, __false_type>::_Ret _SelectFirstRet;
    CPPUNIT_ASSERT( type_to_value(_SelectFirstRet()) == 1 );
    typedef __selectT<__false_type, __true_type, __false_type>::_Ret _SelectSecondRet;
    CPPUNIT_ASSERT( type_to_value(_SelectSecondRet()) == 0 );
#  endif
  }

  {
    base b;
    derived d;
    const derived cd = d;
    base *pb = &b;
    derived *pd = &d;
    derived const *pcd = pd;
    CPPUNIT_CHECK( is_convertible(any, b) == 0 );
    CPPUNIT_CHECK( is_convertible(d, b) == 1 );
    CPPUNIT_CHECK( is_convertible(cd, b) == 1 );
    // _IsCVConvertible only needs to work for pointer type:
    //CPPUNIT_CHECK( is_cv_convertible(d, b) == 1 );
    //CPPUNIT_CHECK( is_cv_convertible(cd, b) == 0 );

    //_IsConvertible do not need to work for pointers:
    //CPPUNIT_CHECK( is_convertible(pd, pb) == 1 );
    //CPPUNIT_CHECK( is_convertible(pcd, pb) == 1 );

    CPPUNIT_CHECK( is_cv_convertible(pd, pb) == 1 );
    CPPUNIT_CHECK( is_cv_convertible(pcd, pb) == 0 );
  }
#endif
}

#if defined (STLPORT)
template <typename _Type>
int is_integer(_Type) {
  typedef typename _IsIntegral<_Type>::_Ret _Ret;
  return type_to_value(_Ret());
}
#endif

void TypeTraitsTest::integer()
{
#if defined (STLPORT)
  CPPUNIT_ASSERT( is_integer(bool()) == 1 );
  CPPUNIT_ASSERT( is_integer(char()) == 1 );
  typedef signed char signed_char;
  CPPUNIT_ASSERT( is_integer(signed_char()) == 1 );