20.tuple.elem.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"
 
 
#include <rw_valcmp.h>
 
#define BOOL_VAL    true
#define CHAR_VAL    'a'
#define INT_VAL     256
#define DBL_VAL     3.14159
#define PTR_VAL     ptr_val
#define USER_VAL    user_val
 
static void*        ptr_val;
static UserDefined  user_val;
 
typedef std::tuple<bool, char, int, double, void*, UserDefined> Tuple;
 
static void
test_const_get (const Tuple& t)
{
    rw_info (0, __FILE__, __LINE__, "get (const)");
 
    const bool& b = std::get<0> (t);
    rw_assert (b == BOOL_VAL, __FILE__, __LINE__, "get<0>(t), got %s, "
               "expected %s", b? "true": "false", BOOL_VAL? "true": "false");
 
    const char& c = std::get<1> (t);
    rw_assert (c == CHAR_VAL, __FILE__, __LINE__,
               "get<1>(t), got \'%c\', expected \'%c\'", c, CHAR_VAL);
 
    const int& i = std::get<2> (t);
    rw_assert (i == INT_VAL, __FILE__, __LINE__,
               "get<2>(t), got %d, expected %d", i, INT_VAL);
 
    const double& d = std::get<3> (t);
    rw_assert (0 == rw_dblcmp (d, DBL_VAL), __FILE__, __LINE__,
               "get<3>(t), got %f, expected %f", d, DBL_VAL);
 
    void* const& p = std::get<4> (t);
    rw_assert (p == PTR_VAL, __FILE__, __LINE__,
               "get<4>(t), got %p, expected %p", p, PTR_VAL);
 
    const UserDefined& uc = std::get<5> (t);
    rw_assert (uc == USER_VAL, __FILE__, __LINE__,
               "get<5>(t), got %d, expected %d",
               uc.value (), USER_VAL.value ());
}
 
 
static void
test_get (Tuple& t)
{
    rw_info (0, __FILE__, __LINE__, "get");
 
    bool& b = std::get<0> (t);
    rw_assert (b == BOOL_VAL, __FILE__, __LINE__,
               "get<0>(t), got %d, expected %b", b, BOOL_VAL);
    b = !BOOL_VAL;
    rw_assert (std::get<0> (t) == !BOOL_VAL, __FILE__, __LINE__,
               "get<0>(t), got %d, expected %b", std::get<0> (t),
               !BOOL_VAL);
 
    char& c = std::get<1> (t);
    rw_assert (c == 'a', __FILE__, __LINE__,
               "get<1>(t), got %c, expected \'%c\'", c, CHAR_VAL);
    c = '1';
    rw_assert (std::get<1> (t) == '1', __FILE__, __LINE__,
               "get<1>(t), got %c, expected \'1\'", std::get<1> (t));
 
    int& i = std::get<2> (t);
    rw_assert (i == INT_VAL, __FILE__, __LINE__,
               "get<2>(t), got %d, expected %d", i, INT_VAL);
    i = INT_VAL+1;
    rw_assert (std::get<2> (t) == INT_VAL+1, __FILE__, __LINE__,
               "get<1>(t), got %d, expected %d", std::get<2> (t),
               INT_VAL+1);
 
    double& d = std::get<3> (t);
    rw_assert (0 == rw_dblcmp (d, DBL_VAL), __FILE__, __LINE__,
               "get<3>(t), got %f, expected %f", d, DBL_VAL);
    d = DBL_VAL*DBL_VAL;
    rw_assert (0 == rw_dblcmp (std::get<3> (t), DBL_VAL*DBL_VAL),
               __FILE__, __LINE__,
               "get<3>(t), got %f, expected %f", std::get<3> (t),
               DBL_VAL*DBL_VAL);
 
    void* p = std::get<4> (t);
    rw_assert (p == PTR_VAL, __FILE__, __LINE__,
               "get<4>(t), got %p, expected %p", p, PTR_VAL);
    p = &d;
    rw_assert (std::get<4> (t) == &d, __FILE__, __LINE__,
               "get<4>(t), got %p, expected %p", std::get<4> (t), &d);
 
    UserDefined& uc = std::get<5> (t);
    rw_assert (uc == USER_VAL, __FILE__, __LINE__,
               "get<5>(t), got %d, expected %d",
               uc.value (), USER_VAL.value ());
    uc = UserDefined (INT_VAL);
    rw_assert ((std::get<5> (t)).value () == INT_VAL, __FILE__, __LINE__,
               "get<5>(t), got %d, expected %d",
               (std::get<5> (t)).value (), INT_VAL);
}
 
 
static int
run_test (int /*argc*/, char* argv [])
{
    ptr_val = static_cast<void*> (argv [0]);
    Tuple t (BOOL_VAL, CHAR_VAL, INT_VAL, DBL_VAL, PTR_VAL, USER_VAL);
 
    test_const_get (t);
    test_get (t);
 
    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.elem]", "20.3.1.5  Element access",
                    run_test, "", 0);
}