20.tuple.creation.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 <functional>           // for reference_wrapper
#include <tuple>
 
#include "20.tuple.h"
 
 
typedef std::reference_wrapper<int>         IntRefWrap;
 
static void
test_make_tuple ()
{
    rw_info (0, __FILE__, __LINE__, "make_tuple");
 
    std::tuple<int> it1 = std::make_tuple (1);
 
    int i = 2;
    std::tuple<int, int> it2 = std::make_tuple (1, i);
 
    const int j = 3;
    std::tuple<int, int, int> it3 = std::make_tuple (1, i, j);
 
    std::tuple<int&> rt1 = std::make_tuple (std::ref (i));
 
    std::tuple<const int&> rt2 = std::make_tuple (std::cref (i));
}
 
 
#include <cstring>
 
static void
test_tie ()
{
    rw_info (0, __FILE__, __LINE__, "tie");
 
    int i = 0; double d = 0.0; const char* s = 0;
    std::tie (i, std::ignore, s)
        = std::make_tuple (256, 3.14159, "string");
 
    rw_assert (i == 256, __FILE__, __LINE__,
               "i == 256, got false, expected true");
    rw_assert (d == 0.0, __FILE__, __LINE__,
               "d == 0.0, got false, expected true");
    rw_assert (0 == std::strcmp (s, "string"), __FILE__, __LINE__,
               "s == \"string\", got false, expected true");
}
 
 
static void
test_tuple_cat ()
{
    rw_info (0, __FILE__, __LINE__, "tuple_cat");
 
#define FirstHalf       bool, char, int, double
#define SecondHalf      void*, UserDefined
 
    typedef std::tuple<FirstHalf>   FirstTuple;
    FirstTuple t1 (true, 'a', 256, 3.14159);
 
    typedef std::tuple<SecondHalf>  SecondTuple;
    SecondTuple t2 (&t1, UserDefined ());
 
    typedef std::tuple<FirstHalf, SecondHalf>   WholeTuple;
    //WholeTuple t3 (tuple_cat (t1, t2));
}
 
 
static int
run_test (int /*argc*/, char* /*argv*/ [])
{
    const void* p = _RWSTD_STATIC_CAST (const void*, &std::ignore);
    _RWSTD_UNUSED (p);
 
    test_make_tuple ();
    test_tie ();
    test_tuple_cat ();
 
    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.creation]",
                    "20.3.1.3  Tuple creation functions",
                    run_test, "", 0);
}