stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vi...@apache.org
Subject svn commit: r681820 [7/7] - in /stdcxx/trunk: ./ doc/ etc/config/src/ examples/include/ include/ include/loc/ include/rw/ src/ tests/containers/ tests/diagnostics/ tests/include/ tests/intro/ tests/localization/ tests/regress/ tests/src/ tests/strings/...
Date Fri, 01 Aug 2008 20:51:22 GMT
Copied: stdcxx/trunk/tests/utilities/20.tuple.creation.cpp (from r672948, stdcxx/branches/4.3.x/tests/utilities/20.tuple.creation.cpp)
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/utilities/20.tuple.creation.cpp?p2=stdcxx/trunk/tests/utilities/20.tuple.creation.cpp&p1=stdcxx/branches/4.3.x/tests/utilities/20.tuple.creation.cpp&r1=672948&r2=681820&rev=681820&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/tests/utilities/20.tuple.creation.cpp (original)
+++ stdcxx/trunk/tests/utilities/20.tuple.creation.cpp Fri Aug  1 13:51:17 2008
@@ -28,8 +28,9 @@
 
 #include <rw_driver.h>
 
- // compile out all test code if extensions disabled
- #ifndef _RWSTD_NO_EXT_CXX_0X
+// 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>
@@ -45,47 +46,58 @@
 {
     rw_info (0, __FILE__, __LINE__, "make_tuple");
 
-    IntTuple it1 = std::make_tuple (1);
+    std::tuple<int> it1 = std::make_tuple (1);
 
-    typedef std::tuple<int, int>        IntTuple2;
     int i = 2;
-    IntTuple2 it2 = std::make_tuple (1, i);
+    std::tuple<int, int> it2 = std::make_tuple (1, i);
 
-    typedef std::tuple<int, int, int>   IntTuple3;
     const int j = 3;
-    IntTuple3 it3 = std::make_tuple (1, i, j);
+    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");
 }
 
 /**************************************************************************/
 
-#define Big1stPart  bool, char, int, double
-#define Big2ndPart  void*, UserClass
-
 static void
 test_tuple_cat ()
 {
     rw_info (0, __FILE__, __LINE__, "tuple_cat");
 
-#define Big1stPart  bool, char, int, double
-#define Big2ndPart  void*, UserClass
+#define FirstHalf       bool, char, int, double
+#define SecondHalf      void*, UserDefined
 
-    typedef std::tuple<Big1stPart> Big1stTuple;
-    Big1stTuple bt1 (true, 'a', 256, 3.14159);
+    typedef std::tuple<FirstHalf>   FirstTuple;
+    FirstTuple t1 (true, 'a', 256, 3.14159);
 
-    typedef std::tuple<Big2ndPart> Big2ndTuple;
-    Big2ndTuple bt2 (&bt1, UserClass ());
+    typedef std::tuple<SecondHalf>  SecondTuple;
+    SecondTuple t2 (&t1, UserDefined ());
 
-    //BigTuple bt (tuple_cat (bt1, bt2));
+    typedef std::tuple<FirstHalf, SecondHalf>   WholeTuple;
+    //WholeTuple t3 (tuple_cat (t1, t2));
 }
 
 /**************************************************************************/
@@ -103,17 +115,28 @@
     return 0;
 }
 
-#else // !_RWSTD_NO_EXT_CXX_0X
+#else // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
 static int
 run_test (int, char*[])
 {
-    rw_info (0, 0, __LINE__,
-             "tests for C++0x tuple extension disabled");
+#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
+#endif // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
 /*extern*/ int
 main (int argc, char* argv [])

Modified: stdcxx/trunk/tests/utilities/20.tuple.elem.cpp
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/utilities/20.tuple.elem.cpp?rev=681820&r1=681819&r2=681820&view=diff
==============================================================================
--- stdcxx/trunk/tests/utilities/20.tuple.elem.cpp (original)
+++ stdcxx/trunk/tests/utilities/20.tuple.elem.cpp Fri Aug  1 13:51:17 2008
@@ -2,7 +2,7 @@
  *
  * 20.tuple.elem.cpp - tests exercising tuple element accessors
  *
- * $Id$
+ * $Id: 20.tuple.elem.cpp 677985 2008-07-18 18:05:55Z elemings $
  *
  ***************************************************************************
  *
@@ -11,7 +11,7 @@
  * 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
+ * except in  compliance with the License.   You may otain  a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
@@ -22,54 +22,166 @@
  * implied.   See  the License  for  the  specific language  governing
  * permissions and limitations under the License.
  *
- * Copyright 2008 Rogue Wave Software.
- * 
+ * 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"
 
 /**************************************************************************/
 
-#include <rw_driver.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_get ()
+test_const_get (const Tuple& t)
 {
-    rw_info (0, __FILE__, __LINE__, "get");
+    rw_info (0, __FILE__, __LINE__, "get (const)");
 
-    IntTuple it (4);
-    rw_assert (std::get<0> (it) == 4, __FILE__, __LINE__,
-               "get<0> (it), got %d, expected 4", std::get<0> (it));
+    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_const_get ()
+test_get (Tuple& t)
 {
-    rw_info (0, __FILE__, __LINE__, "get (const)");
+    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 /*unused*/, char* /*unused*/ [])
+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*[])
 {
-    test_get ();
-    test_const_get ();
+
+#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",
+                    "[tuple.elem]", "20.3.1.5  Element access",
                     run_test, "", 0);
 }
 

Modified: stdcxx/trunk/tests/utilities/20.tuple.h
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/utilities/20.tuple.h?rev=681820&r1=681819&r2=681820&view=diff
==============================================================================
--- stdcxx/trunk/tests/utilities/20.tuple.h (original)
+++ stdcxx/trunk/tests/utilities/20.tuple.h Fri Aug  1 13:51:17 2008
@@ -2,7 +2,7 @@
  *
  * 20.tuple.h - framework for tuple tests
  *
- * $Id$
+ * $Id: 20.tuple.h 677985 2008-07-18 18:05:55Z elemings $
  *
  ***************************************************************************
  *
@@ -22,31 +22,203 @@
  * implied.   See  the License  for  the  specific language  governing
  * permissions and limitations under the License.
  *
- * Copyright 2008 Rogue Wave Software.
- * 
+ * Copyright 2008 Rogue Wave Software, Inc.
+ *
  **************************************************************************/
 
 #ifndef RW_20_TUPLE_H_INCLUDED
 #define RW_20_TUPLE_H_INCLUDED
 
+#include <ostream>              // for std::ostream
 #include <tuple>
+#include <type_traits>          // for std::decay
+#include <utility>              // for std::move
+
+
+// user-defined class for tuple testing (similar to UserClass)
+
+class UserDefined
+{
+
+    int                 value_;         // some arbitrary value
+
+public:
+
+    // types
+
+    typedef int         value_type;
+    typedef unsigned    size_type;
+
+    struct count_type   // number of constructors/operators called
+    {
+        size_type   dflt_ctor;
+        size_type   copy_ctor;
+        size_type   tmpl_ctor;
+        size_type   move_ctor;
+        size_type   copy_asgn;
+        size_type   tmpl_asgn;
+        size_type   move_asgn;
+    };
+
+    static count_type   actual;         // since last reset()
+    static count_type   expect;         // modified by expect()
+
+
+    // constructors
+
+    UserDefined ()
+        : value_ () { ++actual.dflt_ctor; }
+
+    UserDefined (const UserDefined& src)
+        : value_ (src.value_) { ++actual.copy_ctor; }
+
+#if !defined _RWSTD_NO_RVALUE_REFERENCES
+
+    UserDefined (UserDefined&& src)
+        : value_ (std::move (src.value_))
+        { ++actual.move_ctor; }
+
+    // Requires: U is convertible to `value_type'.
+    template <class U >
+    explicit UserDefined (U&& u)
+        : value_ (std::move (u)) { ++actual.tmpl_ctor; }
+
+#endif   // !defined _RWSTD_NO_RVALUE_REFERENCES
+
+
+    // assignment
+
+    UserDefined& operator= (const UserDefined& src)
+    {
+        value_ = src.value_;
+        ++actual.copy_asgn;
+        return *this;
+    }
+
+    template <class U>
+    UserDefined& operator= (const U& src)
+    {
+        value_ = src;
+        ++actual.tmpl_asgn;
+        return *this;
+    }
+
+#if !defined _RWSTD_NO_RVALUE_REFERENCES
+
+    UserDefined& operator= (const UserDefined&& src)
+    {
+        value_ = std::move (src.value_);
+        ++actual.move_asgn;
+        return *this;
+    }
+
+#endif   // !defined _RWSTD_NO_RVALUE_REFERENCES
+
+
+    // accessors
+
+    value_type value () const { return value_; }
+
+
+    // testing
+
+    static void reset ()
+    {
+        actual.dflt_ctor = actual.copy_ctor = actual.tmpl_ctor =
+        actual.move_ctor = actual.copy_asgn = actual.move_asgn =
+        actual.tmpl_asgn = 0;
+
+        expect.dflt_ctor = expect.copy_ctor = expect.tmpl_ctor =
+        expect.move_ctor = expect.copy_asgn = expect.move_asgn =
+        expect.tmpl_asgn = 0;
+    }
+
+
+    // implicit value_type conversion?
+};
+
+UserDefined::count_type
+UserDefined::actual = { 0, 0, 0, 0, 0, 0, 0 };
+
+UserDefined::count_type
+UserDefined::expect = { 0, 0, 0, 0, 0, 0, 0 };
+
+inline bool
+operator== (const UserDefined& lhs, const UserDefined& rhs)
+{
+    return lhs.value () == rhs.value ();
+}
+
+inline bool
+operator< (const UserDefined& lhs, const UserDefined& rhs)
+{
+    return lhs.value () < rhs.value ();
+}
+
+/**************************************************************************/
+
+// tuple names
+
+template <class T>
+struct type_name_ { static const char* value; };
+
+#define TYPE_NAME(T)    \
+template <> const char* type_name_<T>::value = #T;
+
+TYPE_NAME (std::tuple<>)
+TYPE_NAME (std::tuple<int>)
+TYPE_NAME (std::tuple<const int>)
+TYPE_NAME (std::tuple<int&>)
+TYPE_NAME (std::tuple<std::tuple<int> >)
+TYPE_NAME (std::tuple<UserDefined>)
+
+#undef TYPE_NAME
+#define TYPE_NAME(T, S) \
+template <> const char* type_name_<T>::value = S;
+
+#undef TUPLE
+#define TUPLE           std::tuple<long, const char*>
+TYPE_NAME (TUPLE, "std::tuple<long, const char*>")
+
+#undef TUPLE
+#define TUPLE           \
+std::tuple<bool, char, int, double, void*, UserDefined>
+TYPE_NAME (TUPLE, "std::tuple<bool, char, int, double, void*, " \
+                  "UserDefined>")
+
+#undef TUPLE
+
+#undef TYPE_NAME
+#define TYPE_NAME(T)    type_name_<T>::value
+
+/**************************************************************************/
 
-#include <rw_value.h>                       // for UserClass
+// formatting specifiers
 
+template <class T>
+struct fmt_spec { static const char* value; };
 
-// various tuple types for test purposes
+#define FMT_SPEC(T, S)  \
+template <> const char* fmt_spec<T>::value = #S;
 
-typedef std::tuple < >                      EmptyTuple;
-typedef std::tuple < int >                  IntTuple;
-typedef std::tuple < const int >            ConstIntTuple;
-typedef std::tuple < long, const char* >    PairTuple;
-typedef std::tuple < UserClass >            UserTuple;
-typedef std::tuple < std::tuple < int > >   NestedTuple;
+FMT_SPEC (bool, %b)
+FMT_SPEC (char, %c)
+FMT_SPEC (int, %d)
+FMT_SPEC (unsigned, %u)
+FMT_SPEC (long, %ld)
+FMT_SPEC (float, %f)
+FMT_SPEC (double, %f)
+FMT_SPEC (char*, %s)
+FMT_SPEC (char const*, %s)
+FMT_SPEC (void*, %p)
+FMT_SPEC (void const*, %p)
 
-#define BigList      bool, char, int, double, void*, UserClass
-#define BigListSize  6
+#undef DECAY
+#define DECAY(T)        typename std::decay<T>::type
 
-typedef std::tuple < BigList >              BigTuple;
+// ignore cv-qualifiers and references
+#undef FMT_SPEC
+#define FMT_SPEC(T)     fmt_spec<DECAY (T)>::value
 
 
 #endif   // define RW_20_TUPLE_H_INCLUDED

Modified: stdcxx/trunk/tests/utilities/20.tuple.helpers.cpp
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/utilities/20.tuple.helpers.cpp?rev=681820&r1=681819&r2=681820&view=diff
==============================================================================
--- stdcxx/trunk/tests/utilities/20.tuple.helpers.cpp (original)
+++ stdcxx/trunk/tests/utilities/20.tuple.helpers.cpp Fri Aug  1 13:51:17 2008
@@ -2,7 +2,7 @@
  *
  * 20.tuple.helpers.cpp - tests exercising tuple helpers
  *
- * $Id$
+ * $Id: 20.tuple.helpers.cpp 677985 2008-07-18 18:05:55Z elemings $
  *
  ***************************************************************************
  *
@@ -22,18 +22,22 @@
  * implied.   See  the License  for  the  specific language  governing
  * permissions and limitations under the License.
  *
- * Copyright 2008 Rogue Wave Software.
- * 
+ * 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"
 
 /**************************************************************************/
 
-#include <rw_driver.h>
-
 static void
 test_tuple_size ()
 {
@@ -45,16 +49,22 @@
                "tuple_size<" #T ">::value, got %d, expected " \
                STRING (S), std::tuple_size<T>::value)
 
-    TEST (EmptyTuple, 0);
+    TEST (std::tuple<>, 0);
 
-    TEST (IntTuple, 1);
-    TEST (ConstIntTuple, 1);
-    TEST (UserTuple, 1);
-    TEST (NestedTuple, 1);
+    TEST (std::tuple<int>, 1);
+    TEST (std::tuple<const int>, 1);
+    TEST (std::tuple<UserDefined>, 1);
+    TEST (std::tuple<std::tuple<int> >, 1);
 
-    TEST (PairTuple, 2);
+#undef TUPLE
+#define TUPLE std::tuple<long, const char*>
 
-    TEST (BigTuple, BigListSize);
+    TEST (TUPLE, 2);
+
+#undef TUPLE
+#define TUPLE std::tuple<bool, char, int, double, void*, UserDefined>
+
+    TEST (TUPLE, 6);
 }
 
 /**************************************************************************/
@@ -69,7 +79,7 @@
     enum {
         inherited,
         const_int,
-        user_class,
+        user_defined,
         int_tuple
     } type_id;
 
@@ -82,8 +92,8 @@
     any_t (const int)
         : rw_any_t (char ()), type_id (const_int) { }
 
-    any_t (UserClass)
-        : rw_any_t (char ()), type_id (user_class) { }
+    any_t (UserDefined)
+        : rw_any_t (char ()), type_id (user_defined) { }
 
     any_t (std::tuple< int >)
         : rw_any_t (char ()), type_id (int_tuple) { }
@@ -91,7 +101,7 @@
     const char* type_name () const
     {
         return type_id == const_int? "const int":
-               type_id == user_class? "UserClass":
+               type_id == user_defined? "UserDefined":
                type_id == int_tuple? "std::tuple<int>":
                rw_any_t::type_name ();
     }
@@ -102,32 +112,43 @@
 {
     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 T ## N; \
-    rw_assert (IS_SAME(T ## N, E), __FILE__, __LINE__, \
+{ \
+    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 (T##N))
+               "expected type \"" #E "\"", TYPE_NAME (elem_type)); \
+}
 
-    TEST (0, IntTuple, int);
-    TEST (0, ConstIntTuple, const int);
-    TEST (0, NestedTuple, std::tuple<int>);
-    TEST (0, UserTuple, UserClass);
-
-    TEST (0, PairTuple, long);
-    TEST (1, PairTuple, const char*);
-
-    TEST (0, BigTuple, bool);
-    TEST (1, BigTuple, char);
-    TEST (2, BigTuple, int);
-    TEST (3, BigTuple, double);
-    TEST (4, BigTuple, void*);
-    TEST (5, BigTuple, UserClass);
+    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)
 }
 
 /**************************************************************************/
@@ -141,6 +162,30 @@
     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 [])
 {

Copied: stdcxx/trunk/tests/utilities/20.tuple.rel.cpp (from r672948, stdcxx/branches/4.3.x/tests/utilities/20.tuple.rel.cpp)
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/utilities/20.tuple.rel.cpp?p2=stdcxx/trunk/tests/utilities/20.tuple.rel.cpp&p1=stdcxx/branches/4.3.x/tests/utilities/20.tuple.rel.cpp&r1=672948&r2=681820&rev=681820&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/tests/utilities/20.tuple.rel.cpp (original)
+++ stdcxx/trunk/tests/utilities/20.tuple.rel.cpp Fri Aug  1 13:51:17 2008
@@ -29,7 +29,8 @@
 #include <rw_driver.h>
 
 // compile out all test code if extensions disabled
-#ifndef _RWSTD_NO_EXT_CXX_0X
+#if    !defined (_RWSTD_NO_EXT_CXX_0X) \
+    && !defined (_RWSTD_NO_RVALUE_REFERENCES)
 
 #include <tuple>
 
@@ -42,31 +43,36 @@
 {
     rw_info (0, __FILE__, __LINE__, "operator==");
 
-    EmptyTuple nt1, nt2;
+    std::tuple<> nt1, nt2;
+    // special case
     rw_assert (nt1 == nt1, __FILE__, __LINE__,
                "nt1 == nt1, got false, expected true");
-    rw_assert (nt1 == nt2, __FILE__, __LINE__,
-               "nt1 == nt2, got true, expected false");
 
-    IntTuple it1 (1), it2 (1);
-    rw_assert (it1 == it1, __FILE__, __LINE__,
-               "it1 == it1, got false, expected true");
-    rw_assert (it1 == it2, __FILE__, __LINE__,
-               "it1 == it2, got false, expected true");
-
-    UserClass uc;
-    UserTuple ut1 (uc), ut2 (uc);
-    rw_assert (ut1 == ut1, __FILE__, __LINE__,
-               "ut1 == ut1, got false, expected true");
-    rw_assert (ut1 == ut2, __FILE__, __LINE__,
-               "ut1 == ut2, got false, expected true");
-
-    BigTuple bt1 (true, 'a', 256, 3.14159, &nt1, uc);
-    BigTuple bt2 (true, 'a', 256, 3.14159, &nt1, uc);
-    rw_assert (bt1 == bt1, __FILE__, __LINE__,
-               "bt1 == bt1, got false, expected true");
-    rw_assert (bt1 == bt2, __FILE__, __LINE__,
-               "bt1 == bt2, got false, expected true");
+#undef TEST
+#define TEST(expr)      \
+    rw_assert (expr, __FILE__, __LINE__, #expr \
+               "; got %b, expected %b", !(expr), expr)
+
+    TEST (nt1 == nt2);
+
+    std::tuple<int> it1 (1), it2 (1), it3 (2);
+    TEST (it1 == it1);
+    TEST (it1 == it2);
+    TEST (!(it1 == it3));
+
+    UserDefined ud1 (1), ud2 (2);
+    std::tuple<UserDefined> ut1 (ud1), ut2 (ud1), ut3 (ud2);
+    TEST (ut1 == ut1);
+    TEST (ut1 == ut2);
+    TEST (!(ut1 == ut3));
+
+    std::tuple<bool, char, int, double, void*, UserDefined>
+        bt1 (true, 'a', 255, 3.14159, &nt1, ud1),
+        bt2 (true, 'a', 255, 3.14159, &nt1, ud1),
+        bt3 (true, 'a', 256, 3.14159, &nt1, ud1);
+    TEST (bt1 == bt1);
+    TEST (bt1 == bt2);
+    TEST (!(bt1 == bt3));
 }
 
 /**************************************************************************/
@@ -76,27 +82,36 @@
 {
     rw_info (0, __FILE__, __LINE__, "operator<");
 
-    EmptyTuple nt1, nt2;
-    rw_assert (!(nt1 < nt1), __FILE__, __LINE__,
-               "nt1 < nt1, got true, expected false");
-    rw_assert (!(nt1 < nt2), __FILE__, __LINE__,
-               "nt1 < nt2, got true, expected false");
-
-    IntTuple it1 (1), it2 (2);
-    rw_assert (it1 < it2, __FILE__, __LINE__,
-               "it1 < it2, got false, expected true");
-
-    UserClass uc1, uc2;
-    uc1.data_.val_ = 1, uc2.data_.val_ = 2;
-
-    UserTuple ut1 (uc1), ut2 (uc2);
-    rw_assert (ut1 < ut2, __FILE__, __LINE__,
-               "ut1 < ut2, got false, expected true");
-
-    BigTuple bt1 (true, 'a', 255, 3.14159, &nt1, uc1);
-    BigTuple bt2 (true, 'a', 256, 3.14159, &nt1, uc1);
+    std::tuple<> nt1, nt2;
+    TEST (!(nt1 < nt1));
+    TEST (!(nt1 < nt2));
+
+    std::tuple<int> it1 (1), it2 (2);
+    TEST (!(it1 < it1));
+    TEST (it1 < it2);
+
+    UserDefined ud1 (1), ud2 (2);
+    std::tuple<UserDefined> ut1 (ud1), ut2 (ud2);
+    TEST (!(ut1 < ut1));
+    TEST (ut1 < ut2);
+
+    std::tuple<long, const char*> pt1 (1234L, "string");
+    TEST (!(pt1 < pt1));
+    std::tuple<long, const char*> pt2 (1235L, "string");
+    TEST (pt1 < pt2);
+    std::tuple<long, const char*> pt3 (1234L, "strings");
+    TEST (pt1 < pt3);
+
+    std::tuple<bool, char, int, double, void*, UserDefined>
+        bt1 (true, 'a', 255, 3.14159, &nt1, ud1),
+        bt2 (true, 'a', 256, 3.14159, &nt1, ud1),
+        bt3 (true, 'a', 255, 3.14159, &nt1, ud2);
+    rw_assert (!(bt1 < bt1), __FILE__, __LINE__,
+               "bt1 < bt1, got true, expected false");
     rw_assert (bt1 < bt2, __FILE__, __LINE__,
                "bt1 < bt2, got false, expected true");
+    rw_assert (bt1 < bt3, __FILE__, __LINE__,
+               "bt1 < bt3, got false, expected true");
 }
 
 /**************************************************************************/
@@ -115,17 +130,29 @@
     return 0;
 }
 
-#else // !_RWSTD_NO_EXT_CXX_0X
+#else // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
 static int
 run_test (int, char*[])
 {
-    rw_info (0, 0, __LINE__,
-             "tests for C++0x tuple extension disabled");
+
+#if defined (_RWSTD_NO_RVALUE_REFERENCES)
+
+    rw_warn (0, 0, __LINE__,
+             "test disabled because _RWSTD_NO_EXT_CXX_OX 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
+#endif // _RWSTD_NO_EXT_CXX_0X || _RWSTD_NO_RVALUE_REFERENCES
 
 /*extern*/ int
 main (int argc, char* argv [])



Mime
View raw message