20.meta.trans.other.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>
 
#include <rw_printf.h> // for rwsprintfa()
 
#include <stdlib.h>    // for free()
#include <stddef.h>    // for size_t
 
 
template <class T>
struct is_char
{
    enum { val = 0 };
};
 
_RWSTD_SPECIALIZED_CLASS
struct is_char<char>
{
    enum { val = 1 };
};
 
// this function should available _only_ if T is char
template <class T>
int
enabled_if_char (typename std::enable_if<is_char<T>::val>::type* = 0)
{
    return 1;
}
 
// this function should be available if T is _not_ char
template <class T>
int
enabled_if_char (typename std::enable_if<!is_char<T>::val>::type* = 0)
{
    return 0;
}
 
// must have external linkage
int _cond_if_char (void*)
{
    return 0;
}
 
// must have external linkage
int _cond_if_char (long*)
{
    return 1;
}
 
template <class T>
int cond_if_char ()
{
    typedef typename
    std::conditional<is_char<T>::val, long, void>::type selector;
 
    return _cond_if_char ((selector*)0);
}
 
 
 
void test_trait (int line,
                 bool select,
                 const char* trait,
                 const char* typeT,
                 const char* typeU,
                 bool success)
{
    rw_assert (success, 0, line,
               "%s<%b, %s, %s>::type is%{?}n't%{;} %s as expected",
               trait, select, typeT, typeU, !success, select ? typeT : typeU);
}
 
void test_trait (int line, const char* trait,
                 const char* typeT, const char* typeU,
                 bool success)
{
    rw_assert (success, 0, line,
               "%s<%s>::type is%{?}n't%{;} %s as expected",
               trait, typeT, !success, typeU);
}
 
void test_enable_if (int line, const char* typeT, int got, int exp)
{
    const bool success = got == exp;
 
    rw_assert (success, 0, line, "%s is%{?}n't%{;} %b as expected",
               typeT, !success, exp);
}
 
void test_aligned_storage(int line,
                          size_t exp_sz, size_t got_sz,
                          size_t exp_al, size_t got_al)
{
    //
    rw_assert (exp_sz <= got_sz, 0, line,
        "std::aligned_storage<%zu, %zu>::type size is %zu; "
        "expected %zu or more", exp_sz, exp_al, got_sz, exp_sz);
 
    if (exp_al != 0) {
        // alignment should be greater than or equal to expected
        rw_assert (exp_al <= got_al, 0, line,
            "std::aligned_storage<%zu, %zu>::type alignment is %zu; "
            "expected %zu or more", exp_sz, exp_al, got_al, exp_al);
    }
    else {
        // alignment should be less than or equal to the size of
        // the object
        rw_assert (got_al <= exp_sz, 0, line,
            "std::aligned_storage<%zu, %zu>::type alignment is %zu; "
            "expected %zu or less", exp_sz, exp_al, got_al, exp_sz);
    }
 
    const bool is_pow_2 = (got_al & (got_al - 1)) == 0;
    rw_assert (is_pow_2, 0, line,
        "std::aligned_storage<%zu, %zu>::type alignment expected "
        "to be a power-of-two; got %zu", exp_sz, exp_al, got_al);
}
 
 
static void test_aligned_storage ()
{
#ifdef _RWSTD_NO_ALIGN_TRAITS
 
    rw_warn (0, 0, __LINE__,
             "test_aligned_storage disabled because "
             "_RWSTD_NO_ALIGN_TRAITS is defined");
 
#else
 
#define TEST(Size,Align)                                           \
    {                                                              \
      typedef std::aligned_storage<Size, Align>::type storage_t;   \
      test_aligned_storage(__LINE__,                               \
          Size, sizeof (storage_t), Align,                         \
          std::alignment_of<storage_t>::value);                    \
    } typedef void __dummy
 
    TEST (1, 1);
    TEST (1, 2);
    TEST (1, 4);
    TEST (1, 8);
 
    TEST (9, 1);
    TEST (9, 2);
    TEST (9, 4);
    TEST (9, 8);
 
    TEST (55, 1);
    TEST (23, 2);
    TEST (17, 4);
    TEST (19, 8);
 
#undef  TEST
#define TEST(Size)                                                 \
    {                                                              \
      typedef std::aligned_storage<Size>::type storage_t;          \
      test_aligned_storage(__LINE__,                               \
          Size, sizeof (storage_t), 0,                             \
          std::alignment_of<storage_t>::value);                    \
    } typedef void __dummy
 
    // test default alignment
    TEST (1);
    TEST (2);
    TEST (4);
    TEST (8);
 
    TEST (3);
    TEST (5);
    TEST (7);
    TEST (9);
 
    TEST (55);
    TEST (23);
    TEST (17);
    TEST (19);
 
#undef  TEST
 
#endif // _RWSTD_NO_ALIGN_TRAITS
}
 
 
#ifndef _RWSTD_NO_ALIGN_TRAITS
 
struct null_t { };
 
// get the maximum of 8 values
size_t max8(size_t a1, size_t a2, size_t a3, size_t a4,
            size_t a5, size_t a6, size_t a7, size_t a8)
{
    size_t r = a1;
 
    if (r < a2) r = a2;
    if (r < a3) r = a3;
    if (r < a4) r = a4;
    if (r < a5) r = a5;
    if (r < a6) r = a6;
    if (r < a7) r = a7;
    if (r < a8) r = a8;
 
    return r;
}
 
template <size_t Len,
          class T1         , class T2 = null_t,
          class T3 = null_t, class T4 = null_t,
          class T5 = null_t, class T6 = null_t,
          class T7 = null_t, class T8 = null_t>
struct aligned_union_tester
{
    static void test (int line,
               const char* t1    , const char* t2 = 0,
               const char* t3 = 0, const char* t4 = 0,
               const char* t5 = 0, const char* t6 = 0,
               const char* t7 = 0, const char* t8 = 0)
    {
        const char* arr[] = {
            t1, t2, t3, t4, t5, t6, t7, t8
        };
 
        char* pbuf = 0;
        size_t bufsz = 0;
 
        // get the list of template arguments in one buffer
        rw_asnprintf(&pbuf, &bufsz, "%zu", Len);
        for (size_t i = 0; i < sizeof (arr) / sizeof (*arr); ++i)
        {
            if (!arr [i])
                break;
 
            rw_asnprintf (&pbuf, &bufsz, "%{+}, %s", arr [i]);
        }
 
        typedef std::aligned_union<Len,T1,T2,T3,T4,T5,T6,T7,T8> aligned_t;
        typedef typename aligned_t::type aligned_type_t;
 
        const bool pass1 =    std::alignment_of<aligned_type_t>::value
                           == aligned_t::alignment_value;
        rw_assert (pass1, 0, line,
                   "std::aligned_union<%s>::alignment_value is %zu; "
                   "expected %zu",
                   pbuf, aligned_t::alignment_value, 
                   std::alignment_of<aligned_type_t>::value); 
 
        const size_t exp_al = max8(std::alignment_of<T1>::value,
                                   std::alignment_of<T2>::value,
                                   std::alignment_of<T3>::value,
                                   std::alignment_of<T4>::value,
                                   std::alignment_of<T5>::value,
                                   std::alignment_of<T6>::value,
                                   std::alignment_of<T7>::value,
                                   std::alignment_of<T8>::value);
        const size_t got_al = std::alignment_of<aligned_type_t>::value;
 
        const bool pass2 = exp_al == got_al;
        rw_assert (pass2, 0, line,
                   "std::aligned_union<%s>::type alignment is %zu; "
                   "expected %zu",
                   pbuf, got_al, exp_al); 
 
        const size_t min_sz = Len;
        const size_t got_sz = sizeof (aligned_type_t);
 
        const bool pass3 = min_sz <= got_sz;
 
        rw_assert (pass3, 0, __LINE__,
                   "std::aligned_union<%s>::type size is %zu; expected "
                   "at least %zu",
                   pbuf, got_sz, min_sz);
 
        free (pbuf);
    }
};
 
struct struct_t { };
 
#endif // !_RWSTD_NO_ALIGN_TRAITS
 
 
static void test_aligned_union ()
{
#ifdef _RWSTD_NO_ALIGN_TRAITS
 
    rw_warn (0, 0, __LINE__,
             "test_aligned_union disabled because "
             "_RWSTD_NO_ALIGN_TRAITS is defined");
 
#else
 
#define TEST(Len,T1) \
    aligned_union_tester<Len,T1>::test(__LINE__,#T1)
 
    TEST (1, char);
    TEST (1, long);
    TEST (1, void*);
    TEST (1, void (struct_t::*)());
 
    TEST (2, char);
    TEST (2, long);
    TEST (2, void*);
    TEST (2, void (struct_t::*)());
 
    TEST (12, char);
    TEST (12, long);
    TEST (12, void*);
    TEST (12, void (struct_t::*)());
 
#undef  TEST
#define TEST(Len,T1,T2) \
    aligned_union_tester<Len,T1,T2>::test(__LINE__,#T1,#T2)
 
    TEST (11, char, long);
    TEST (134, long, long);
    TEST (7, void*, long);
    TEST (1, void (struct_t::*)(), long);
 
    TEST (2, char, long);
    TEST (2, long, long);
    TEST (2, void*, long);
    TEST (2, void (struct_t::*)(), long);
 
#undef  TEST
#define TEST(Len,T1,T2,T3,T4,T5) \
    aligned_union_tester<Len,T1,T2,T3,T4,T5>::test(__LINE__,#T1,#T2,#T3,#T4,#T5)
 
    TEST (12, char, short, int, long, void*);
    TEST (13, void*, long, long, long, int);
    TEST (17, void (struct_t::*)(), long, int, void*, char);
 
#undef  TEST
 
#endif // _RWSTD_NO_ALIGN_TRAITS
}
 
 
static void test_decay ()
{
#define TEST(Trait,TypeT,TypeU)                                \
    test_trait(__LINE__, #Trait, #TypeT, #TypeU,               \
               std::is_same<Trait<TypeT>::type, TypeU>::value)
 
    // equal to remove_extent<remove_reference<T>::type>::type* for arrays
    TEST (std::decay, int[ ], int*);
    TEST (std::decay, int[2], int*);
    TEST (std::decay, int[2][2], int (*)[2]);
 
    // equal to add_pointer<remove_reference<U>::type>::type for functions
    TEST (std::decay, int(), int (*)());
    TEST (std::decay, int(char, long), int (*)(char, long));
 
    TEST (std::decay, int(&)(), int (*)());
    TEST (std::decay, int(&)(char, long), int (*)(char, long));
 
    // otherwise equal to remove_cv<remove_reference<U>::type>::type
    TEST (std::decay,                int, int);
    TEST (std::decay, const          int, int);
    TEST (std::decay,       volatile int, int);
    TEST (std::decay, const volatile int, int);
 
    TEST (std::decay,                int&, int);
    TEST (std::decay, const          int&, int);
    TEST (std::decay,       volatile int&, int);
    TEST (std::decay, const volatile int&, int);
 
#undef TEST
}
 
 
enum enum_t { E_a = 1 };
 
static void test_enable_if ()
{
    typedef std::enable_if<true, int>::type int_type;
 
#define TEST(Cond,Expect) \
    test_enable_if(__LINE__, #Cond, Cond, Expect)
 
    TEST (enabled_if_char<         char>(), 1);
    TEST (enabled_if_char<  signed char>(), 0);
    TEST (enabled_if_char<unsigned char>(), 0);
 
    TEST (enabled_if_char<         short>(), 0);
    TEST (enabled_if_char<  signed short>(), 0);
    TEST (enabled_if_char<unsigned short>(), 0);
 
    TEST (enabled_if_char<         int>(), 0);
    TEST (enabled_if_char<  signed int>(), 0);
    TEST (enabled_if_char<unsigned int>(), 0);
 
    TEST (enabled_if_char<         long>(), 0);
    TEST (enabled_if_char<  signed long>(), 0);
    TEST (enabled_if_char<unsigned long>(), 0);
 
    // miscellaneous other stuff to try and expose problems
    TEST (enabled_if_char<char    ()>(), 0);
    TEST (enabled_if_char<char (*)()>(), 0);
    TEST (enabled_if_char<char (&)()>(), 0);
 
    TEST (enabled_if_char<char    [1]>(), 0);
    TEST (enabled_if_char<char (*)[1]>(), 0);
    TEST (enabled_if_char<char (&)[1]>(), 0);
 
    TEST (enabled_if_char<enum_t>(), 0);
 
#undef TEST
}
 
 
static void test_conditional ()
{
#define TEST(Cond,Expect) \
    test_enable_if(__LINE__, #Cond, Cond, Expect)
 
    TEST (cond_if_char<void>(), 0);
    TEST (cond_if_char<char>(), 1);
 
#undef  TEST
#define TEST(Trait,Select,TypeT,TypeU,TypeV)                             \
    test_trait(__LINE__, Select, #Trait, #TypeT, #TypeU,                 \
               std::is_same<Trait<Select,TypeT,TypeU>::type, TypeV>::value)
 
    TEST (std::conditional,  true, char, long, char);
    TEST (std::conditional, false, char, long, long);
 
#undef TEST
}
 
 
static int run_test (int, char*[])
{
    test_aligned_storage ();
    test_aligned_union ();
    test_decay ();
    test_enable_if ();
    test_conditional ();
 
    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.trans.other",
                    0 /* no comment */,
                    run_test,
                    0);
}