20.meta.unary.comp.cpp

Go to the documentation of this file.

// -*- C++ -*-
 
#include <rw_driver.h>
#include <rw/_defs.h>
 
// compile out all test code if extensions disabled
#ifndef _RWSTD_NO_EXT_CXX_0X
 
#include <type_traits>
 
 
class class_t {
    long l_; float f_;
};
 
struct struct_t {
    long l_; float f_;
};
 
union union_t {
    long l_; float f_;
};
 
enum enum_t {
    E_a, E_b, E_c
};
 
 
void test_trait (int line, bool value, bool expect,
                 const char* trait, const char* type)
{
    rw_assert (value == expect, 0, line,
               "%s<%s> is %b, expected %b",
               trait, type, value, expect);
}
 
#define _TEST(Trait,Type,Expect)                                     \
    test_trait (__LINE__, Trait<Type>::value, Expect, #Trait, #Type)                  
 
#define TEST(Trait,Type,Expect)                                      \
    _TEST(Trait, Type, Expect);                                      \
    _TEST(Trait, std::add_const<Type>::type, Expect);                \
    _TEST(Trait, std::add_volatile<Type>::type, Expect);             \
    _TEST(Trait, std::add_cv<Type>::type, Expect)
 
 
void test_is_arithmetic ()
{
    // void
    TEST (std::is_arithmetic, void, false);
 
    // integral
    TEST (std::is_arithmetic,          bool, true);
 
    TEST (std::is_arithmetic,          char, true);
    TEST (std::is_arithmetic,   signed char, true);
    TEST (std::is_arithmetic, unsigned char, true);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_arithmetic,       wchar_t, true);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_arithmetic,          short, true);
    TEST (std::is_arithmetic,   signed short, true);
    TEST (std::is_arithmetic, unsigned short, true);
 
    TEST (std::is_arithmetic,          int, true);
    TEST (std::is_arithmetic,   signed int, true);
    TEST (std::is_arithmetic, unsigned int, true);
 
    TEST (std::is_arithmetic,          long, true);
    TEST (std::is_arithmetic,   signed long, true);
    TEST (std::is_arithmetic, unsigned long, true);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_arithmetic,          long long, true);
    TEST (std::is_arithmetic,   signed long long, true);
    TEST (std::is_arithmetic, unsigned long long, true);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_arithmetic,       float, true);
    TEST (std::is_arithmetic,      double, true);
    TEST (std::is_arithmetic, long double, true);
 
    // array
    TEST (std::is_arithmetic, long [4], false);
    TEST (std::is_arithmetic, float [3][3], false);
    TEST (std::is_arithmetic, char* [4], false);
    TEST (std::is_arithmetic, class_t [], false);
    TEST (std::is_arithmetic, struct_t [][2], false);
 
    // pointer
    TEST (std::is_arithmetic, long*, false);
    TEST (std::is_arithmetic, char**, false);
 
    // reference
    TEST (std::is_arithmetic, int&, false);
    TEST (std::is_arithmetic, union_t&, false);
    TEST (std::is_arithmetic, class_t&, false);
    TEST (std::is_arithmetic, union_t&, false);
    TEST (std::is_arithmetic, class_t&, false);
    TEST (std::is_arithmetic, double&, false);
 
    // pointer to member
    TEST (std::is_arithmetic, long (class_t::*), false);
    TEST (std::is_arithmetic, int (struct_t::*), false);
 
    // pointer to member function
    TEST (std::is_arithmetic, double (class_t::*)(), false);
    TEST (std::is_arithmetic, long (class_t::*)(float), false);
    TEST (std::is_arithmetic, double (struct_t::*)(), false);
    TEST (std::is_arithmetic, long (struct_t::*)(float), false);
    
    // enumeration
    TEST (std::is_arithmetic, enum_t, false);
 
    // union
    TEST (std::is_arithmetic, union_t, false);
 
    // class
    TEST (std::is_arithmetic, class_t, false);
    TEST (std::is_arithmetic, struct_t, false);
 
    // function
    TEST (std::is_arithmetic, long (), false);
    TEST (std::is_arithmetic, float (char), false);
 
    // function pointer
    TEST (std::is_arithmetic, long (*)(), false);
    TEST (std::is_arithmetic, double (*)(int), false);
 
    // function reference
    TEST (std::is_arithmetic, long (&)(), false);
 
    // member function reference
    //TEST (std::is_arithmetic, long (class_t::&), false);
}
 
void test_is_fundamental ()
{
    // void
    TEST (std::is_fundamental, void, true);
 
    // integral
    TEST (std::is_fundamental,          bool, true);
 
    TEST (std::is_fundamental,          char, true);
    TEST (std::is_fundamental,   signed char, true);
    TEST (std::is_fundamental, unsigned char, true);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_fundamental,       wchar_t, true);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_fundamental,          short, true);
    TEST (std::is_fundamental,   signed short, true);
    TEST (std::is_fundamental, unsigned short, true);
 
    TEST (std::is_fundamental,          int, true);
    TEST (std::is_fundamental,   signed int, true);
    TEST (std::is_fundamental, unsigned int, true);
 
    TEST (std::is_fundamental,          long, true);
    TEST (std::is_fundamental,   signed long, true);
    TEST (std::is_fundamental, unsigned long, true);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_fundamental,          long long, true);
    TEST (std::is_fundamental,   signed long long, true);
    TEST (std::is_fundamental, unsigned long long, true);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_fundamental,       float, true);
    TEST (std::is_fundamental,      double, true);
    TEST (std::is_fundamental, long double, true);
 
    // array
    TEST (std::is_fundamental, long [4], false);
    TEST (std::is_fundamental, float [3][3], false);
    TEST (std::is_fundamental, char* [4], false);
    TEST (std::is_fundamental, class_t [], false);
    TEST (std::is_fundamental, struct_t [][2], false);
 
    // pointer
    TEST (std::is_fundamental, long*, false);
    TEST (std::is_fundamental, char**, false);
 
    // reference
    TEST (std::is_fundamental, int&, false);
    TEST (std::is_fundamental, union_t&, false);
    TEST (std::is_fundamental, class_t&, false);
    TEST (std::is_fundamental, union_t&, false);
    TEST (std::is_fundamental, class_t&, false);
    TEST (std::is_fundamental, double&, false);
 
    // pointer to member
    TEST (std::is_fundamental, long (class_t::*), false);
    TEST (std::is_fundamental, int (struct_t::*), false);
 
    // pointer to member function
    TEST (std::is_fundamental, double (class_t::*)(), false);
    TEST (std::is_fundamental, long (class_t::*)(float), false);
    TEST (std::is_fundamental, double (struct_t::*)(), false);
    TEST (std::is_fundamental, long (struct_t::*)(float), false);
    
    // enumeration
    TEST (std::is_fundamental, enum_t, false);
 
    // union
    TEST (std::is_fundamental, union_t, false);
 
    // class
    TEST (std::is_fundamental, class_t, false);
    TEST (std::is_fundamental, struct_t, false);
 
    // function
    TEST (std::is_fundamental, long (), false);
    TEST (std::is_fundamental, float (char), false);
 
    // function pointer
    TEST (std::is_fundamental, long (*)(), false);
    TEST (std::is_fundamental, double (*)(int), false);
 
    // function reference
    TEST (std::is_fundamental, long (&)(), false);
 
    // member function reference
    //TEST (std::is_fundamental, long (class_t::&), false);
}
 
void test_is_object ()
{
    // an object type is a (possibly cv-qualified) type that is not a
    // function type, not a reference type, and not a void type.
 
    // void
    TEST (std::is_object, void, false);
 
    // integral
    TEST (std::is_object,          bool, true);
 
    TEST (std::is_object,          char, true);
    TEST (std::is_object,   signed char, true);
    TEST (std::is_object, unsigned char, true);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_object,       wchar_t, true);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_object,          short, true);
    TEST (std::is_object,   signed short, true);
    TEST (std::is_object, unsigned short, true);
 
    TEST (std::is_object,          int, true);
    TEST (std::is_object,   signed int, true);
    TEST (std::is_object, unsigned int, true);
 
    TEST (std::is_object,          long, true);
    TEST (std::is_object,   signed long, true);
    TEST (std::is_object, unsigned long, true);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_object,          long long, true);
    TEST (std::is_object,   signed long long, true);
    TEST (std::is_object, unsigned long long, true);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_object,       float, true);
    TEST (std::is_object,      double, true);
    TEST (std::is_object, long double, true);
 
    // array
    TEST (std::is_object, long [4], true);
    TEST (std::is_object, float [3][3], true);
    TEST (std::is_object, char* [4], true);
    TEST (std::is_object, class_t [], true);
    TEST (std::is_object, struct_t [][2], true);
 
    // pointer
    TEST (std::is_object, long*, true);
    TEST (std::is_object, char**, true);
 
    // reference
    TEST (std::is_object, int&, false);
    TEST (std::is_object, union_t&, false);
    TEST (std::is_object, class_t&, false);
    TEST (std::is_object, union_t&, false);
    TEST (std::is_object, class_t&, false);
    TEST (std::is_object, double&, false);
 
    // pointer to member
    TEST (std::is_object, long (class_t::*), true);
    TEST (std::is_object, int (struct_t::*), true);
 
    // pointer to member function
    TEST (std::is_object, double (class_t::*)(), true);
    TEST (std::is_object, long (class_t::*)(float), true);
    TEST (std::is_object, double (struct_t::*)(), true);
    TEST (std::is_object, long (struct_t::*)(float), true);
    
    // enumeration
    TEST (std::is_object, enum_t, true);
 
    // union
    TEST (std::is_object, union_t, true);
 
    // class
    TEST (std::is_object, class_t, true);
    TEST (std::is_object, struct_t, true);
 
    // function
    TEST (std::is_object, long (), false);
    TEST (std::is_object, float (char), false);
 
    // function pointer
    TEST (std::is_object, long (*)(), true);
    TEST (std::is_object, double (*)(int), true);
 
    // function reference
    TEST (std::is_object, long (&)(), false);
 
    // member function reference
    //TEST (std::is_object, long (class_t::&), false);
}
 
void test_is_scalar ()
{
    // arithmetic types, enumeration types, pointer types, pointer to member
    // types and std::nullptr_t, and cv-qualified versions of these types
    // are collectively called scalar types.
 
    // void
    TEST (std::is_scalar, void, false);
 
    // integral
    TEST (std::is_scalar,          bool, true);
 
    TEST (std::is_scalar,          char, true);
    TEST (std::is_scalar,   signed char, true);
    TEST (std::is_scalar, unsigned char, true);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_scalar,       wchar_t, true);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_scalar,          short, true);
    TEST (std::is_scalar,   signed short, true);
    TEST (std::is_scalar, unsigned short, true);
 
    TEST (std::is_scalar,          int, true);
    TEST (std::is_scalar,   signed int, true);
    TEST (std::is_scalar, unsigned int, true);
 
    TEST (std::is_scalar,          long, true);
    TEST (std::is_scalar,   signed long, true);
    TEST (std::is_scalar, unsigned long, true);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_scalar,          long long, true);
    TEST (std::is_scalar,   signed long long, true);
    TEST (std::is_scalar, unsigned long long, true);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_scalar,       float, true);
    TEST (std::is_scalar,      double, true);
    TEST (std::is_scalar, long double, true);
 
    // array
    TEST (std::is_scalar, long [4], false);
    TEST (std::is_scalar, float [3][3], false);
    TEST (std::is_scalar, char* [4], false);
    TEST (std::is_scalar, class_t [], false);
    TEST (std::is_scalar, struct_t [][2], false);
 
    // pointer
    TEST (std::is_scalar, long*, true);
    TEST (std::is_scalar, char**, true);
 
    // reference
    TEST (std::is_scalar, int&, false);
    TEST (std::is_scalar, union_t&, false);
    TEST (std::is_scalar, class_t&, false);
    TEST (std::is_scalar, union_t&, false);
    TEST (std::is_scalar, class_t&, false);
    TEST (std::is_scalar, double&, false);
 
    // pointer to member
    TEST (std::is_scalar, long (class_t::*), true);
    TEST (std::is_scalar, int (struct_t::*), true);
 
    // pointer to member function
    TEST (std::is_scalar, double (class_t::*)(), true);
    TEST (std::is_scalar, long (class_t::*)(float), true);
    TEST (std::is_scalar, double (struct_t::*)(), true);
    TEST (std::is_scalar, long (struct_t::*)(float), true);
    
    // enumeration
    TEST (std::is_scalar, enum_t, true);
 
    // union
    TEST (std::is_scalar, union_t, false);
 
    // class
    TEST (std::is_scalar, class_t, false);
    TEST (std::is_scalar, struct_t, false);
 
    // function
    TEST (std::is_scalar, long (), false);
    TEST (std::is_scalar, float (char), false);
 
    // function pointer
    TEST (std::is_scalar, long (*)(), true);
    TEST (std::is_scalar, double (*)(int), true);
 
    // function reference
    TEST (std::is_scalar, long (&)(), false);
 
    // member function reference
    //TEST (std::is_scalar, long (class_t::&), false);
}
 
void test_is_compound ()
{
    // arrays, functions, pointers, function pointers,
    // references, function references, classes, unions,
    // enumerations, pointer to non-static class members
 
    // void
    TEST (std::is_compound, void, false);
 
    // integral
    TEST (std::is_compound,          bool, false);
 
    TEST (std::is_compound,          char, false);
    TEST (std::is_compound,   signed char, false);
    TEST (std::is_compound, unsigned char, false);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_compound,       wchar_t, false);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_compound,          short, false);
    TEST (std::is_compound,   signed short, false);
    TEST (std::is_compound, unsigned short, false);
 
    TEST (std::is_compound,          int, false);
    TEST (std::is_compound,   signed int, false);
    TEST (std::is_compound, unsigned int, false);
 
    TEST (std::is_compound,          long, false);
    TEST (std::is_compound,   signed long, false);
    TEST (std::is_compound, unsigned long, false);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_compound,          long long, false);
    TEST (std::is_compound,   signed long long, false);
    TEST (std::is_compound, unsigned long long, false);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_compound,       float, false);
    TEST (std::is_compound,      double, false);
    TEST (std::is_compound, long double, false);
 
    // array
    TEST (std::is_compound, long [4], true);
    TEST (std::is_compound, float [3][3], true);
    TEST (std::is_compound, char* [4], true);
    TEST (std::is_compound, class_t [], true);
    TEST (std::is_compound, struct_t [][2], true);
 
    // pointer
    TEST (std::is_compound, void*, true);
    TEST (std::is_compound, long*, true);
    TEST (std::is_compound, char**, true);
 
    // reference
    TEST (std::is_compound, int&, true);
    TEST (std::is_compound, union_t&, true);
    TEST (std::is_compound, class_t&, true);
    TEST (std::is_compound, union_t&, true);
    TEST (std::is_compound, class_t&, true);
    TEST (std::is_compound, double&, true);
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (std::is_compound, union_t&&, true);
    TEST (std::is_compound, double&&, true);
#endif
 
    // pointer to member
    TEST (std::is_compound, long (class_t::*), true);
    TEST (std::is_compound, int (struct_t::*), true);
 
    // pointer to member function
    TEST (std::is_compound, double (class_t::*)(), true);
    TEST (std::is_compound, long (class_t::*)(float), true);
    TEST (std::is_compound, double (struct_t::*)(), true);
    TEST (std::is_compound, long (struct_t::*)(float), true);
    
    // enumeration
    TEST (std::is_compound, enum_t, true);
 
    // union
    TEST (std::is_compound, union_t, true);
 
    // class
    TEST (std::is_compound, class_t, true);
    TEST (std::is_compound, struct_t, true);
 
    // function
    TEST (std::is_compound, long (), true);
    TEST (std::is_compound, float (char), true);
 
    // function pointer
    TEST (std::is_compound, long (*)(), true);
    TEST (std::is_compound, double (*)(int), true);
 
    // function reference
    TEST (std::is_compound, long (&)(), true);
 
    // member function reference
    typedef long (class_t::*memfun_t_ptr)();
    typedef std::remove_pointer<memfun_t_ptr>::type memfun_t;
    typedef std::add_lvalue_reference<memfun_t>::type memfun_t_ref;
    TEST (std::is_compound, memfun_t_ref, true);
}
 
void test_is_member_pointer ()
{
    // void
    TEST (std::is_member_pointer, void, false);
 
    // integral
    TEST (std::is_member_pointer,          bool, false);
 
    TEST (std::is_member_pointer,          char, false);
    TEST (std::is_member_pointer,   signed char, false);
    TEST (std::is_member_pointer, unsigned char, false);
 
#ifndef _RWSTD_NO_WCHAR_T
    TEST (std::is_member_pointer,       wchar_t, false);
#endif   // _RWSTD_NO_WCHAR_T
 
    TEST (std::is_member_pointer,          short, false);
    TEST (std::is_member_pointer,   signed short, false);
    TEST (std::is_member_pointer, unsigned short, false);
 
    TEST (std::is_member_pointer,          int, false);
    TEST (std::is_member_pointer,   signed int, false);
    TEST (std::is_member_pointer, unsigned int, false);
 
    TEST (std::is_member_pointer,          long, false);
    TEST (std::is_member_pointer,   signed long, false);
    TEST (std::is_member_pointer, unsigned long, false);
 
#ifndef _RWSTD_NO_LONG_LONG
    TEST (std::is_member_pointer,          long long, false);
    TEST (std::is_member_pointer,   signed long long, false);
    TEST (std::is_member_pointer, unsigned long long, false);
#endif   // _RWSTD_NO_LONG_LONG
 
    // floating point
    TEST (std::is_member_pointer,       float, false);
    TEST (std::is_member_pointer,      double, false);
    TEST (std::is_member_pointer, long double, false);
 
    // array
    TEST (std::is_member_pointer, long [4], false);
    TEST (std::is_member_pointer, float [3][3], false);
    TEST (std::is_member_pointer, char* [4], false);
    TEST (std::is_member_pointer, class_t [], false);
    TEST (std::is_member_pointer, struct_t [][2], false);
 
    // pointer
    TEST (std::is_member_pointer, long*, false);
    TEST (std::is_member_pointer, char**, false);
 
    // reference
    TEST (std::is_member_pointer, int&, false);
    TEST (std::is_member_pointer, union_t&, false);
    TEST (std::is_member_pointer, class_t&, false);
    TEST (std::is_member_pointer, union_t&, false);
    TEST (std::is_member_pointer, class_t&, false);
    TEST (std::is_member_pointer, double&, false);
 
    // pointer to member
    TEST (std::is_member_pointer, long (class_t::*), true);
    TEST (std::is_member_pointer, int (struct_t::*), true);
 
    // pointer to member function
    TEST (std::is_member_pointer, double (class_t::*)(), true);
    TEST (std::is_member_pointer, long (class_t::*)(float), true);
    TEST (std::is_member_pointer, double (struct_t::*)(), true);
    TEST (std::is_member_pointer, long (struct_t::*)(float), true);
    
    // enumeration
    TEST (std::is_member_pointer, enum_t, false);
 
    // union
    TEST (std::is_member_pointer, union_t, false);
 
    // class
    TEST (std::is_member_pointer, class_t, false);
    TEST (std::is_member_pointer, struct_t, false);
 
    // function
    TEST (std::is_member_pointer, long (), false);
    TEST (std::is_member_pointer, float (char), false);
 
    // function pointer
    TEST (std::is_member_pointer, long (*)(), false);
    TEST (std::is_member_pointer, double (*)(int), false);
 
    // function reference
    TEST (std::is_member_pointer, long (&)(), false);
 
    // member function reference
    //TEST (std::is_member_pointer, long (class_t::&), false);    
}
 
 
static int run_test (int, char*[])
{
    test_is_arithmetic ();
    test_is_fundamental ();
    test_is_object ();
    test_is_scalar ();
    test_is_compound ();
    test_is_member_pointer ();
 
    return 0;
}
 
 
#else // _RWSTD_NO_EXT_CXX_0X
 
 
static int run_test (int, char*[])
{
    rw_warn (0, 0, __LINE__,
             "test disabled because _RWSTD_NO_EXT_CXX_0X is defined");
    return 0;
}
 
#endif // !_RWSTD_NO_EXT_CXX_0X
 
 
int main (int argc, char*argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "meta.unary.comp",
                    0 /* no comment*/,
                    run_test,
                    0);
}