tests/utilities/20.tuple.helpers.cpp

/***************************************************************************
 *
 * 20.tuple.helpers.cpp - tests exercising tuple helpers
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2008 Rogue Wave Software, Inc.
 *
 **************************************************************************/

#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);
}