20.tuple.helpers.cpp

Go to the documentation of this file.

 
#include <rw_driver.h>
 
// compile out all test code if extensions disabled
#if    !defined (_RWSTD_NO_EXT_CXX_0X) \
    && !defined (_RWSTD_NO_RVALUE_REFERENCES)
 
#include <tuple>
 
#include "20.tuple.h"
 
 
static void
test_tuple_size ()
{
    rw_info (0, __FILE__, __LINE__, "tuple_size");
 
#define STRING(x)   #x
#define TEST(T, S)  \
    rw_assert (std::tuple_size<T>::value == S, __FILE__, __LINE__, \
               "tuple_size<" #T ">::value, got %d, expected " \
               STRING (S), std::tuple_size<T>::value)
 
    TEST (std::tuple<>, 0);
 
    TEST (std::tuple<int>, 1);
    TEST (std::tuple<const int>, 1);
    TEST (std::tuple<UserDefined>, 1);
    TEST (std::tuple<std::tuple<int> >, 1);
 
#undef TUPLE
#define TUPLE std::tuple<long, const char*>
 
    TEST (TUPLE, 2);
 
#undef TUPLE
#define TUPLE std::tuple<bool, char, int, double, void*, UserDefined>
 
    TEST (TUPLE, 6);
}
 
 
#include <rw/_meta_rel.h>
 
#include <rw_any.h>
 
class any_t : public rw_any_t
{
private:
    enum {
        inherited,
        const_int,
        user_defined,
        int_tuple
    } type_id;
 
public:
 
    template <class Type>
    any_t (Type)
        : rw_any_t (Type ()), type_id (inherited) { }
 
    any_t (const int)
        : rw_any_t (char ()), type_id (const_int) { }
 
    any_t (UserDefined)
        : rw_any_t (char ()), type_id (user_defined) { }
 
    any_t (std::tuple< int >)
        : rw_any_t (char ()), type_id (int_tuple) { }
 
    const char* type_name () const
    {
        return type_id == const_int? "const int":
               type_id == user_defined? "UserDefined":
               type_id == int_tuple? "std::tuple<int>":
               rw_any_t::type_name ();
    }
};
 
static void
test_tuple_element ()
{
    rw_info (0, __FILE__, __LINE__, "tuple_element");
 
#undef IS_SAME
#define IS_SAME(T,U) \
        _RW::__rw_is_same<T, U>::value
 
#undef TYPE_NAME
#define TYPE_NAME(T) \
        (any_t (T ())).type_name ()
 
#undef TEST
#define TEST(N, T, E) \
{ \
    typedef std::tuple_element<N, T>::type elem_type; \
    rw_assert (IS_SAME(elem_type, E), __FILE__, __LINE__, \
               "tuple_element<0, " #T ">::type, got type \"%s\", " \
               "expected type \"" #E "\"", TYPE_NAME (elem_type)); \
}
 
    TEST (0, std::tuple<int>, int)
    TEST (0, std::tuple<const int>, const int)
    TEST (0, std::tuple<std::tuple<int> >, std::tuple<int>)
    TEST (0, std::tuple<UserDefined>, UserDefined)
 
#undef TUPLE
#define TUPLE std::tuple<long, const char*>
 
    TEST (0, TUPLE, long)
    TEST (1, TUPLE, const char*)
 
#undef TUPLE
#define TUPLE std::tuple<bool, char, int, double, void*, UserDefined>
 
    TEST (0, TUPLE, bool)
    TEST (1, TUPLE, char)
    TEST (2, TUPLE, int)
    TEST (3, TUPLE, double)
    TEST (4, TUPLE, void*)
    TEST (5, TUPLE, UserDefined)
}
 
 
static int
run_test (int /*argc*/, char* /*argv*/ [])
{
    test_tuple_size ();
    test_tuple_element ();
 
    return 0;
}
 
#else // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
static int
run_test (int, char*[])
{
 
#if defined (_RWSTD_NO_EXT_CXX_0X)
 
    rw_warn (0, 0, __LINE__,
             "test disabled because _RWSTD_NO_EXT_CXX_0X is defined");
 
#elif defined (_RWSTD_NO_RVALUE_REFERENCES)
 
    rw_warn (0, 0, __LINE__,
             "test disabled because _RWSTD_NO_RVALUE_REFERENCES is "
             "defined");
 
#endif
 
    return 0;
}
 
#endif // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
/*extern*/ int
main (int argc, char* argv [])
{
    return rw_test (argc, argv, __FILE__,
                    "[tuple.helper]",
                    "20.3.1.4  Tuple helper classes",
                    run_test, "", 0);
}