stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From far...@apache.org
Subject svn commit: r510071 [3/5] - in /incubator/stdcxx/trunk/tests: algorithms/ containers/ include/ numerics/ self/ src/ utilities/
Date Wed, 21 Feb 2007 15:58:56 GMT
Modified: incubator/stdcxx/trunk/tests/algorithms/25.set.union.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.set.union.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.set.union.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.set.union.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -23,6 +30,7 @@
 #include <cstddef>      // for size_t
 
 #include <alg_test.h>
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test()
 
 /**************************************************************************/
@@ -66,7 +74,8 @@
 
     // return a type other than bool but one that is implicitly
     // convertible to bool to detect incorrect assumptions
-    conv_to_bool operator() (const X &x, const X &y) /* non-const */ {
+    conv_to_bool operator() (const UserClass &x,
+                             const UserClass &y) /* non-const */ {
         ++funcalls_;
         return conv_to_bool::make (x.val_ < y.val_);
     }
@@ -87,24 +96,25 @@
     const char* iter_names [3];
 
     // pure virtual, must be overridden
-    virtual X*
-    set_union (const X*, const X*, const X*, const X*,
-               X*, X*, const Less*) const = 0;
+    virtual UserClass*
+    set_union (const UserClass*, const UserClass*, const UserClass*,
+               const UserClass*, UserClass*, UserClass*,
+               const Less*) const = 0;
 };
 
 template <class InputIterator1, class InputIterator2, class OutputIterator>
 struct SetUnion: SetUnionBase
 {
     SetUnion () {
-        iter_names [0] = type_name (InputIterator1 (0, 0, 0), (X*)0);
-        iter_names [1] = type_name (InputIterator2 (0, 0, 0), (X*)0);
-        iter_names [2] = type_name (OutputIterator (0, 0, 0), (X*)0);
+        iter_names [0] = type_name (InputIterator1 (0, 0, 0), (UserClass*)0);
+        iter_names [1] = type_name (InputIterator2 (0, 0, 0), (UserClass*)0);
+        iter_names [2] = type_name (OutputIterator (0, 0, 0), (UserClass*)0);
     }
 
-    virtual X*
-    set_union (const X    *xsrc1, const X *xsrc1_end,
-               const X    *xsrc2, const X *xsrc2_end,
-               X          *xdst, X *xdst_end,
+    virtual UserClass*
+    set_union (const UserClass    *xsrc1, const UserClass *xsrc1_end,
+               const UserClass    *xsrc2, const UserClass *xsrc2_end,
+               UserClass          *xdst, UserClass *xdst_end,
                const Less *ppred) const {
 
         const InputIterator1 first1 (xsrc1,     xsrc1, xsrc1_end);
@@ -144,26 +154,28 @@
     const char* const fname   = "set_union";
     const char* const funname = predicate ? "Less" : 0;
 
-    X* const xsrc1 = X::from_char (src1, nsrc1, true /* must be sorted */);
-    X* const xsrc2 = X::from_char (src2, nsrc2, true /* must be sorted */);
+    UserClass* const xsrc1 = UserClass::from_char (src1, nsrc1,
+                                                   true /* must be sorted */);
+    UserClass* const xsrc2 = UserClass::from_char (src2, nsrc2,
+                                                   true /* must be sorted */);
     // assert that the sequences have been successfully created
     RW_ASSERT (0 == nsrc1 || xsrc1);
     RW_ASSERT (0 == nsrc2 || xsrc2);
 
-    X* const xdst = new X [ndst];
+    UserClass* const xdst = new UserClass [ndst];
 
     const int max1_id = nsrc1 > 0 ? xsrc1 [nsrc1 - 1].id_ : -1;
 
-    X* const xsrc1_end = xsrc1 + nsrc1;
-    X* const xsrc2_end = xsrc2 + nsrc2;
-    X* const xdst_end  = xdst + ndst;
+    UserClass* const xsrc1_end = xsrc1 + nsrc1;
+    UserClass* const xsrc2_end = xsrc2 + nsrc2;
+    UserClass* const xdst_end  = xdst + ndst;
 
-    const std::size_t last_n_op_lt = X::n_total_op_lt_;
+    const std::size_t last_n_op_lt = UserClass::n_total_op_lt_;
 
     const Less pred (0, 0);
     const Less* const ppred = predicate ? &pred : 0;
 
-    const X* const xdst_res =
+    const UserClass* const xdst_res =
         alg.set_union (xsrc1, xsrc1_end, xsrc2, xsrc2_end,
                        xdst, xdst_end, ppred);
 
@@ -184,7 +196,7 @@
     }
 
     const std::size_t n_ops_lt = ppred ? 
-        Less::funcalls_ : X::n_total_op_lt_ - last_n_op_lt;
+        Less::funcalls_ : UserClass::n_total_op_lt_ - last_n_op_lt;
 
     // check the algorithm correctness
     std::size_t i = 0;
@@ -319,13 +331,15 @@
                          bool predicate)
 {
     if (0 == rw_opt_no_output_iter)
-        gen_set_union_test (it1, it2, OutputIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, it2, OutputIter<UserClass>(0, 0, 0),
+                            predicate);
     if (0 == rw_opt_no_fwd_iter)
-        gen_set_union_test (it1, it2, FwdIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, it2, FwdIter<UserClass>(0, 0, 0), predicate);
     if (0 == rw_opt_no_bidir_iter)
-        gen_set_union_test (it1, it2, BidirIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, it2, BidirIter<UserClass>(0, 0, 0), predicate);
     if (0 == rw_opt_no_rnd_iter)
-        gen_set_union_test (it1, it2, RandomAccessIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, it2, RandomAccessIter<UserClass>(0, 0, 0),
+                            predicate);
 }
 
 template <class InputIterator1>
@@ -333,13 +347,14 @@
                          bool                  predicate)
 {
     if (0 == rw_opt_no_input_iter)
-        gen_set_union_test (it1, InputIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, InputIter<UserClass>(0, 0, 0), predicate);
     if (0 == rw_opt_no_fwd_iter)
-        gen_set_union_test (it1, ConstFwdIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, ConstFwdIter<UserClass>(0, 0, 0), predicate);
     if (0 == rw_opt_no_bidir_iter)
-        gen_set_union_test (it1, ConstBidirIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, ConstBidirIter<UserClass>(0, 0, 0), predicate);
     if (0 == rw_opt_no_rnd_iter)
-        gen_set_union_test (it1, ConstRandomAccessIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (it1, ConstRandomAccessIter<UserClass>(0, 0, 0),
+                            predicate);
 }
 
 // generates a specialization of the set_union test for each of the required
@@ -358,22 +373,23 @@
     if (rw_opt_no_input_iter)
         rw_note (0, 0, 0, "InputIterator test disabled");
     else
-        gen_set_union_test (InputIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (InputIter<UserClass>(0, 0, 0), predicate);
 
     if (rw_opt_no_fwd_iter)
         rw_note (0, 0, 0, "ForwardIterator test disabled");
     else
-        gen_set_union_test (ConstFwdIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (ConstFwdIter<UserClass>(0, 0, 0), predicate);
 
     if (rw_opt_no_bidir_iter)
         rw_note (0, 0, 0, "BidirectionalIterator test disabled");
     else
-        gen_set_union_test (ConstBidirIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (ConstBidirIter<UserClass>(0, 0, 0), predicate);
 
     if (rw_opt_no_rnd_iter)
         rw_note (0, 0, 0, "RandomAccessIterator test disabled");
     else
-        gen_set_union_test (ConstRandomAccessIter<X>(0, 0, 0), predicate);
+        gen_set_union_test (ConstRandomAccessIter<UserClass>(0, 0, 0),
+                            predicate);
 }
 
 /**************************************************************************/

Modified: incubator/stdcxx/trunk/tests/algorithms/25.sort.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.sort.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.sort.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.sort.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -24,6 +31,7 @@
 #include <cstddef>      // for ptrdiff_t
 
 #include <alg_test.h>
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test()
 
 /**************************************************************************/
@@ -126,7 +134,7 @@
     _RWSTD_UNUSED (last_n_op_cpy);
 
     if (stable) {
-        std::pair<X*, std::ptrdiff_t> dummy;
+        std::pair<UserClass*, std::ptrdiff_t> dummy;
         if (alloc) {
             dummy = std::_GET_TEMP_BUFFER (T, nsrc + 1);
             rw_assert (0 != dummy.first, 0, 0,
@@ -174,7 +182,8 @@
         if (nsrc > 16 && x < x_min)
             x_min = x;
 
-        // complexity: X * N * log (N), ideally with X approaching 1
+        // complexity: UserClass * N * log (N),
+        // ideally with UserClass approaching 1
 
         if (!(nsrc % 20)) {
             rw_info (0, 0, 0,
@@ -182,7 +191,7 @@
                      "|   N  | COMP | COPY |N lg N|   X  | max X| min X|\n"
                      "+======+======+======+======+======+======+======+\n");
 
-            // # | comp | assign | exp. complexity | X | max X |
+            // # | comp | assign | exp. complexity | X | max X | min X
             rw_info (0, 0, 0, "\n|%6d|%6d|%6d|%6d|%6.2f|%6.2f|%6.2f|\n",
                      nsrc + 1, ops, cpy, cmplx, x, x_max, x_min);
         }
@@ -372,16 +381,16 @@
         rw_note (0, __FILE__, __LINE__, "std::sort test disabled");
     }
     else {
-        test_sort (N, (X*)0, false, false);
+        test_sort (N, (UserClass*)0, false, false);
     }
 
     if (rw_opt_no_stable_sort) {
         rw_note (0, __FILE__, __LINE__, "std::stable_sort test disabled");
     }
     else {
-        test_sort (N, (X*)0, true, false);
+        test_sort (N, (UserClass*)0, true, false);
         // test with memory reallocation
-        test_sort (N, (X*)0, true, true);
+        test_sort (N, (UserClass*)0, true, true);
     }
 
     return 0;

Modified: incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -23,6 +30,7 @@
 #include <cstring>      // for size_t, strlen()
 
 #include <alg_test.h>
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test()
 
 
@@ -105,8 +113,8 @@
 void test_iter_swap (ForwardIterator1 it1, ForwardIterator2 it2, 
                      const T*, bool it_swap)
 {
-    const char* const it1name = it_swap ? type_name (it1, (T*)0) : "X";
-    const char* const it2name = it_swap ? type_name (it2, (T*)0) : "X";
+    const char* const it1name = it_swap ? type_name (it1, (T*)0) : "UserClass";
+    const char* const it2name = it_swap ? type_name (it2, (T*)0) : "UserClass";
     const char* const fname   = it_swap ? "iter_swap" : "swap";
 
     rw_info (0, 0, 0, "std::%s (%s, %s)", fname, it1name, it2name);
@@ -325,7 +333,8 @@
     else {
         rw_info (0, 0, 0, "template <class T> void swap (T&, T&)");
 
-        test_iter_swap (FwdIter<X>(), FwdIter<X>(), (X*)0, false);
+        test_iter_swap (FwdIter<UserClass>(), FwdIter<UserClass>(),
+                        (UserClass*)0, false);
     }
 
     if (rw_opt_no_swap_ranges) {
@@ -337,7 +346,7 @@
                  "swap_ranges (%1$s, %1$s, %2$s)",
                  "ForwardIterator1", "ForwardIterator2");
 
-        test_swap ((X*)0, true);
+        test_swap ((UserClass*)0, true);
     }
 
     if (rw_opt_no_iter_swap) {
@@ -348,7 +357,7 @@
                  "template <class %s, class %s> void iter_swap (%1$s, %2$s)",
                  "ForwardIterator1", "ForwardIterator2");
 
-        test_swap ((X*)0, false);
+        test_swap ((UserClass*)0, false);
     }
 
     return 0;

Modified: incubator/stdcxx/trunk/tests/algorithms/25.transform.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.transform.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.transform.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.transform.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  *
  **************************************************************************/
 
@@ -23,6 +30,7 @@
 #include <cstddef>      // for size_t
 
 #include <alg_test.h>
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test()
 
 
@@ -128,7 +136,7 @@
 OutputIterator
 invoke_transform (InputIterator first, InputIterator last,
                   Unused /* for compatibility with the overload below */,
-                  OutputIterator dest, incT<X> fun)
+                  OutputIterator dest, incT<UserClass> fun)
 {
     return std::transform (first, last, dest, fun);
 }
@@ -137,7 +145,7 @@
 OutputIterator
 invoke_transform (InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2,
-                  OutputIterator dest, plusT<X> fun)
+                  OutputIterator dest, plusT<UserClass> fun)
 {
     return std::transform (first1, last1, first2, dest, fun);
 }
@@ -271,11 +279,11 @@
                int                   tag3,
                int                   same_seq)
 {
-    const InputIter<X>        input_iter (0, 0, 0);
+    const InputIter<UserClass>        input_iter (0, 0, 0);
     const OutputIter<T>       output_iter (0, 0, 0);
     const FwdIter<T>          fwd_iter (0, 0, 0);
     const BidirIter<T>        bidir_iter (0, 0, 0);
-    const RandomAccessIter<X> rand_iter (0, 0, 0);
+    const RandomAccessIter<UserClass> rand_iter (0, 0, 0);
 
     // tag1, tag2 and tag3 indicates that an iterator needs to be generated
     // at the corresponding position by a recursive call to gen_test
@@ -412,9 +420,9 @@
 static int
 run_test (int, char*[])
 {
-    const InputIter<X>        input_iter (0, 0, 0);
-    const RandomAccessIter<X> rand_iter;
-    const X* const            ptr = 0;
+    const InputIter<UserClass>        input_iter (0, 0, 0);
+    const RandomAccessIter<UserClass> rand_iter;
+    const UserClass* const            ptr = 0;
 
     // test transform with a unary function
     // according to 25.2.3 p5 'result may be equal to first'
@@ -424,7 +432,7 @@
                  "std::transform unary function test disabled");
     }
     else {
-        const incT<X>* const pfun = 0;
+        const incT<UserClass>* const pfun = 0;
 
         gen_test (ptr, input_iter, rand_iter, rand_iter,
                   pfun, 1, 0, 1, 0 /* result distinct from first */);
@@ -444,7 +452,7 @@
                  "std::transform binary function test disabled");
     }
     else {
-        const plusT<X>* const pfun = 0;
+        const plusT<UserClass>* const pfun = 0;
 
         gen_test (ptr, input_iter, rand_iter, rand_iter,
                   pfun, 1, 1, 1, 0 /* result distinct from first{1,2} */);

Modified: incubator/stdcxx/trunk/tests/algorithms/25.unique.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.unique.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.unique.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.unique.cpp Wed Feb 21 07:58:53 2007
@@ -6,29 +6,31 @@
  *
  ***************************************************************************
  *
- * Copyright 2006 The Apache Software Foundation or its licensors,
- * as applicable.
+ * 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
  *
- * Copyright 2000-2006 Rogue Wave Software.
- *
- * Licensed 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
+ * 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.
+ * 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 2000-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
 #include <algorithm>    // for unique, unique_copy
 #include <cstring>      // for strlen
 
-#include <alg_test.h>   // for BinaryPredicate, X
+#include <alg_test.h>   // for BinaryPredicate
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test()
 
 /**************************************************************************/
@@ -351,14 +353,14 @@
         rw_note (0, __FILE__, __LINE__,  "std::unique test disabled");
     }
     else {
-        test_unique ((X*)0, (BinaryPredicate*)0, false);
+        test_unique ((UserClass*)0, (BinaryPredicate*)0, false);
 
         if (rw_opt_no_predicate) {
            rw_note (0, __FILE__, __LINE__,  
                     "std::unique predicate test disabled");
         }
         else {
-            test_unique ((X*)0, &pred, false);
+            test_unique ((UserClass*)0, &pred, false);
         }
     }
 
@@ -366,14 +368,14 @@
         rw_note (0, __FILE__, __LINE__,  "std::unique_copy test disabled");
     }
     else {
-        test_unique ((X*) 0, (BinaryPredicate*)0, true);
+        test_unique ((UserClass*) 0, (BinaryPredicate*)0, true);
 
         if (rw_opt_no_predicate) {
            rw_note (0, __FILE__, __LINE__,  
                     "std::unique_copy predicate test disabled");
         }
         else {
-            test_unique ((X*)0, &pred, true);
+            test_unique ((UserClass*)0, &pred, true);
         }
     }
 

Modified: incubator/stdcxx/trunk/tests/algorithms/25.upper.bound.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/algorithms/25.upper.bound.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.upper.bound.cpp (original)
+++ incubator/stdcxx/trunk/tests/algorithms/25.upper.bound.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -31,16 +38,17 @@
 #include <cstring>      // for strlen()
 
 #include <alg_test.h>   // for iterators
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test(), ...
 
 /**************************************************************************/
 
-// distinct and not Less-Than-Comparable with class X (except as
+// distinct and not Less-Than-Comparable with class UserClass (except as
 // defined below) to detect unwarranted assumptions made by the
 // implementation of the algorithms
 struct Y
 {
-    X xval_;
+    UserClass xval_;
 
     // not Default-Constructible
     Y (int /* dummy */, int /*dummy */): xval_ () { }
@@ -55,13 +63,13 @@
 
 
 inline conv_to_bool
-operator< (const X &lhs, const Y &rhs)
+operator< (const UserClass &lhs, const Y &rhs)
 {
     return conv_to_bool::make (lhs < rhs.xval_);
 }
 
 inline conv_to_bool
-operator< (const Y &lhs, const X &rhs)
+operator< (const Y &lhs, const UserClass &rhs)
 {
     return conv_to_bool::make (lhs.xval_ < rhs);
 }
@@ -77,12 +85,12 @@
 
     // return a type other than bool but one that is implicitly
     // convertible to bool to detect incorrect assumptions
-    conv_to_bool operator() (const X &lhs, const Y &rhs) {
+    conv_to_bool operator() (const UserClass &lhs, const Y &rhs) {
         ++funcalls_;
         return conv_to_bool::make (lhs < rhs.xval_);
     }
 
-    conv_to_bool operator() (const Y &lhs, const X &rhs) {
+    conv_to_bool operator() (const Y &lhs, const UserClass &rhs) {
         ++funcalls_;
         return conv_to_bool::make (lhs.xval_ < rhs);
     }
@@ -108,7 +116,7 @@
     RW_ASSERT (0 != src_str);
 
     const std::size_t nsrc = std::strlen (src_str);
-    X* const xsrc = X::from_char (src_str, nsrc);
+    UserClass* const xsrc = UserClass::from_char (src_str, nsrc);
 
     if (nsrc < result_off)
         result_off = nsrc;
@@ -127,8 +135,8 @@
     // when `predicate' is true
     const LessThan comp (0, 0 /* dummy arguments */);
 
-    // reset the counter of invocations of X::operator<()
-    X::n_total_op_lt_ = 0;
+    // reset the counter of invocations of UserClass::operator<()
+    UserClass::n_total_op_lt_ = 0;
 
     // invoke the appropriate form of the algorithm, storing
     // the resturned value
@@ -151,7 +159,7 @@
 
     // verify complexity
     const std::size_t funcalls = predicate
-        ? LessThan::funcalls_ : X::n_total_op_lt_;
+        ? LessThan::funcalls_ : UserClass::n_total_op_lt_;
 
     rw_assert (funcalls <= ncomp, 0, line,
                "upper_bound(%s = \"%s\", ...%{?}%#c%{;}) complexity: "
@@ -174,7 +182,8 @@
                       std::size_t (comp), (ForwardIterator*)0, \
                       itname, predicate)
 
-    rw_info (0, 0, 0, "std::upper_bound (%s, %1$s, const X&%{?}, %s%{;})",
+    rw_info (0, 0, 0,
+             "std::upper_bound (%s, %1$s, const UserClass&%{?}, %s%{;})",
              itname, predicate, "LessThan");
 
     //    +--------------- source sequence
@@ -223,28 +232,30 @@
 test_upper_bound (bool predicate)
 {
     rw_info (0, 0, 0, "template <class %s, class %s%{?}, class %s%{;}> "
-             "std::upper_bound (%1$s, %1$s, const X&%{?}, %4$s%{;})",
-             "ForwardIterator", "X", predicate, "Compare", predicate);
+             "std::upper_bound (%1$s, %1$s, const UserClass&%{?}, %4$s%{;})",
+             "ForwardIterator", "UserClass", predicate, "Compare", predicate);
 
     if (rw_opt_no_fwd_iter) {
         rw_note (0, 0, 0, "ForwardIterator test disabled");
     }
     else {
-        test_upper_bound ((FwdIter<X>*)0, "ForwardIterator", predicate);
+        test_upper_bound ((FwdIter<UserClass>*)0, "ForwardIterator", predicate);
     }
 
     if (rw_opt_no_bidir_iter) {
         rw_note (0, 0, 0, "BidirectionalIterator test disabled");
     }
     else {
-        test_upper_bound ((BidirIter<X>*)0, "BidirectionalIterator", predicate);
+        test_upper_bound ((BidirIter<UserClass>*)0, "BidirectionalIterator",
+                          predicate);
     }
 
     if (rw_opt_no_fwd_iter) {
         rw_note (0, 0, 0, "RandomAccessIterator test disabled");
     }
     else {
-        test_upper_bound ((RandomAccessIter<X>*)0, "RandomAccessIterator",
+        test_upper_bound ((RandomAccessIter<UserClass>*)0,
+                          "RandomAccessIterator",
                           predicate);
     }
 }

Modified: incubator/stdcxx/trunk/tests/containers/23.deque.modifiers.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/containers/23.deque.modifiers.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.deque.modifiers.cpp (original)
+++ incubator/stdcxx/trunk/tests/containers/23.deque.modifiers.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -39,7 +46,7 @@
 #  include <rw_new.h>
 #endif   // _RWSTD_NO_REPLACEABLE_NEW_DELETE
 
-#include <alg_test.h>    // for X
+#include <rw_value.h>    // for UserClass
 #include <driver.h>      // for rw_test(), ...
 #include <rw_printf.h>   // for rw_asnprintf
 
@@ -63,7 +70,7 @@
 
 /**************************************************************************/
 
-typedef std::deque<X, std::allocator<X> > Deque;
+typedef std::deque<UserClass, std::allocator<UserClass> > Deque;
 
 Deque::size_type new_capacity;
 
@@ -114,18 +121,18 @@
 // by throwing an exception; verifies that the exception had no effects
 // on the container
 template <class Iterator>
-void exception_loop (int             line /* line number in caller*/,
-                     MemberFunction  mfun /* deque member function */,
-                     const char     *fcall /* function call string */,
-                     int             exceptions /* enabled exceptions */,
-                     Deque          &deq /* container to call function on */,
+void exception_loop (int              line /* line number in caller*/,
+                     MemberFunction   mfun /* deque member function */,
+                     const char      *fcall /* function call string */,
+                     int              exceptions /* enabled exceptions */,
+                     Deque           &deq /* container to call function on */,
                      const Deque::iterator &it /* iterator into container */,
-                     int             n /* number of elements or offset */,
-                     const X        *x /* pointer to an element or 0 */,
-                     const Iterator &first /* beginning of range */,
-                     const Iterator &last /* end of range to insert */,
-                     int            *n_copy /* number of copy ctors */,
-                     int            *n_asgn /* number of assignments */)
+                     int              n /* number of elements or offset */,
+                     const UserClass *x /* pointer to an element or 0 */,
+                     const Iterator  &first /* beginning of range */,
+                     const Iterator  &last /* end of range to insert */,
+                     int             *n_copy /* number of copy ctors */,
+                     int             *n_asgn /* number of assignments */)
 {
     std::size_t throw_after = 0;
 
@@ -147,13 +154,13 @@
     for ( ; ; ) {
 
         // detect objects constructed but not destroyed after an exception
-        std::size_t x_count = X::count_;
+        std::size_t x_count = UserClass::count_;
 
         _RWSTD_ASSERT (n_copy);
         _RWSTD_ASSERT (n_asgn);
 
-        *n_copy = X::n_total_copy_ctor_;
-        *n_asgn = X::n_total_op_assign_;
+        *n_copy = UserClass::n_total_copy_ctor_;
+        *n_asgn = UserClass::n_total_op_assign_;
 
 #ifndef _RWSTD_NO_EXCEPTIONS
 
@@ -170,11 +177,13 @@
 #  endif   // DEFINE_REPLACEMENT_NEW_AND_DELETE
 
         if (exceptions & CopyCtorThrows) {
-            X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + throw_after;
+            UserClass::copy_ctor_throw_count_ =
+                UserClass::n_total_copy_ctor_ + throw_after;
         }
 
         if (exceptions & AssignmentThrows) {
-            X::op_assign_throw_count_ = X::n_total_op_assign_ + throw_after;
+            UserClass::op_assign_throw_count_ =
+                UserClass::n_total_op_assign_ + throw_after;
         }
 
 #endif   // _RWSTD_NO_EXCEPTIONS
@@ -234,7 +243,7 @@
             
 
             // count the number of objects to detect leaks
-            x_count = X::count_ - x_count;
+            x_count = UserClass::count_ - x_count;
             rw_assert (x_count == deq.size () - size, 0, line,
                        "line %d: %s: leaked %zu objects after an exception",
                        __LINE__, fcall, x_count - (deq.size () - size));
@@ -252,7 +261,7 @@
         }
 
         // count the number of objects to detect leaks
-        x_count = X::count_ - x_count;
+        x_count = UserClass::count_ - x_count;
         rw_assert (x_count == deq.size () - size, 0, line,
                    "line %d: %s: leaked %zu objects "
                    "after a successful insertion",
@@ -268,13 +277,13 @@
 
 #endif   // DEFINE_REPLACEMENT_NEW_AND_DELETE
 
-    X::copy_ctor_throw_count_ = 0;
-    X::op_assign_throw_count_ = 0;
+    UserClass::copy_ctor_throw_count_ = 0;
+    UserClass::op_assign_throw_count_ = 0;
 
-    // compute the number of calls to X copy ctor and assignment operator
-    // and set `n_copy' and `n_assgn' to the value of the result
-    *n_copy = X::n_total_copy_ctor_ - *n_copy;
-    *n_asgn = X::n_total_op_assign_ - *n_asgn;
+    // compute the number of calls to UserClass copy ctor and assignment
+    // operator and set `n_copy' and `n_assgn' to the value of the result
+    *n_copy = UserClass::n_total_copy_ctor_ - *n_copy;
+    *n_asgn = UserClass::n_total_op_assign_ - *n_asgn;
 }
 
 
@@ -323,8 +332,8 @@
                   const char *res, std::size_t reslen)
 {
     // Ensure that xsrc, xins are always dereferenceable
-    const X* const xseq = X::from_char (seq, seqlen + 1);
-          X* const xins = X::from_char (ins, inslen + 1);
+    const UserClass* const xseq = UserClass::from_char (seq, seqlen + 1);
+          UserClass* const xins = UserClass::from_char (ins, inslen + 1);
 
     Deque deq = seqlen ? Deque (xseq, xseq + seqlen) : Deque ();
 
@@ -350,8 +359,8 @@
                   nelems == -2, *ins, nelems == -1, 
                   int (inslen), -1, xins, nelems, *ins);
 
-    int n_copy = X::n_total_copy_ctor_;
-    int n_asgn = X::n_total_op_assign_;
+    int n_copy = UserClass::n_total_copy_ctor_;
+    int n_asgn = UserClass::n_total_op_assign_;
 
     if (-2 == nelems) {   // insert(iterator, const_reference)
 
@@ -423,7 +432,7 @@
     rw_assert (n_copy == int (expect_copy),
                __FILE__, line,
                "line %d: %s: expected %zu invocations "
-               "of X::X(const X&), got %d\n",
+               "of UserClass::UserClass(const UserClass&), got %d\n",
                __LINE__, funcall, expect_copy, n_copy);
 
     // compute the number of calls to the assignment operator
@@ -433,7 +442,7 @@
     rw_assert (n_asgn == int (expect_asgn), 
                __FILE__, line,
                "line %d: %s: expected %zu invocations "
-               "of X::operator=(const X&), got %d\n",
+               "of UserClass::operator=(const UserClass&), got %d\n",
                __LINE__, funcall, expect_asgn, n_asgn);
 
     // Free funcall storage
@@ -449,7 +458,7 @@
 void test_insert_range (const Iterator &it, const char* itname)
 {
     rw_info (0, 0 ,0, 
-             "std::deque<X>::insert(iterator, %s, %s)", itname, itname);
+             "std::deque<UserClass>::insert(iterator, %s, %s)", itname, itname);
 
 #undef TEST
 #define TEST(seq, off, ins, res)                        \
@@ -604,13 +613,14 @@
     //////////////////////////////////////////////////////////////////
     // exercise deque::insert(iterator, const_reference)
 
-    rw_info (0, 0, 0, "std::deque<X>::insert(iterator, const_reference)");
+    rw_info (0, 0, 0,
+             "std::deque<UserClass>::insert(iterator, const_reference)");
 
 #undef TEST
 #define TEST(seq, off, ins, res) do {                   \
       const char insseq [] = { ins, '\0' };             \
       test_insert (__LINE__, -1,                        \
-                              (X*)0, -2,                \
+                              (UserClass*)0, -2,        \
                               seq, sizeof seq - 1,      \
                               std::size_t (off),        \
                               insseq, 1,                \
@@ -725,14 +735,14 @@
     // exercise deque::insert(iterator, size_type, const_reference)
 
     rw_info (0, 0, 0, 
-             "std::deque<X>::insert(iterator, size_type, "
+             "std::deque<UserClass>::insert(iterator, size_type, "
              "const_reference)");
 
 #undef TEST
 #define TEST(seq, off, n, ins, res) do {                \
       const char insseq [] = { ins, '\0' };             \
       test_insert (__LINE__, -1,                        \
-                              (X*)0, n,                 \
+                              (UserClass*)0, n,         \
                               seq, sizeof seq - 1,      \
                               std::size_t (off),        \
                               insseq, 1,                \
@@ -763,39 +773,41 @@
     // exercise deque::insert(iterator, InputIterator, InputIterator)
 
     rw_info (0, 0, 0, 
-             "template <class InputIterator> std::deque<X>::"
+             "template <class InputIterator> std::deque<UserClass>::"
              "insert(iterator, InputIterator, InputIterator)");
 
     if (0 == rw_opt_no_input_iterator)
-        test_insert_range (InputIter<X>(0, 0, 0), "InputIter<X>");
+        test_insert_range (InputIter<UserClass>(0, 0, 0),
+                           "InputIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::insert(iterator, T, T) "
+                 "std::deque<UserClass>::insert(iterator, T, T) "
                  "[with T = InputIterator] test disabled.");
 
     if (0 == rw_opt_no_forward_iterator)
-        test_insert_range (FwdIter<X>(), "FwdIter<X>");
+        test_insert_range (FwdIter<UserClass>(), "FwdIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::insert(iterator, T, T) "
+                 "std::deque<UserClass>::insert(iterator, T, T) "
                  "[with T = ForwardIterator] test disabled.");
 
     if (0 == rw_opt_no_bidirectional_iterator)
-        test_insert_range (BidirIter<X>(), "BidirIter<X>");
+        test_insert_range (BidirIter<UserClass>(), "BidirIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::insert(iterator, T, T) "
+                 "std::deque<UserClass>::insert(iterator, T, T) "
                  "[with T = BidirectionalIterator] test disabled.");
 
     if (0 == rw_opt_no_random_iterator)
-        test_insert_range (RandomAccessIter<X>(), "RandomAccessIter<X>");
+        test_insert_range (RandomAccessIter<UserClass>(),
+                           "RandomAccessIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::insert(iterator, T, T) "
+                 "std::deque<UserClass>::insert(iterator, T, T) "
                  "[with T = RandomAccessIterator] test disabled."); 
 
     //////////////////////////////////////////////////////////////////
@@ -828,7 +840,7 @@
     else
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::insert(iterator, T, T) "
+                 "std::deque<UserClass>::insert(iterator, T, T) "
                  "[with T = IntegralType] tests disabled."); 
 
 }
@@ -842,8 +854,8 @@
                   const char *asn, std::size_t asnlen,
                   const char *res, std::size_t reslen)
 {
-    const X* const xseq = X::from_char (seq, seqlen + 1);
-          X* const xasn = X::from_char (asn, asnlen + 1);
+    const UserClass* const xseq = UserClass::from_char (seq, seqlen + 1);
+          UserClass* const xasn = UserClass::from_char (asn, asnlen + 1);
 
     Deque deq = seqlen ? Deque (xseq, xseq + seqlen) : Deque ();
 
@@ -860,8 +872,8 @@
                   asnlen, -1, xasn, 
                   nelems, *asn);
 
-    int n_copy = X::n_total_copy_ctor_;
-    int n_asgn = X::n_total_op_assign_;
+    int n_copy = UserClass::n_total_copy_ctor_;
+    int n_asgn = UserClass::n_total_op_assign_;
 
     // create a dummy deque iterator to pass to exception_loop
     // (the object will not be used by the functiuon)
@@ -953,12 +965,12 @@
 
     rw_assert (n_copy == int (expect_copy), 0, line,
                "line %d: %s: expected %zu invocations "
-               "of X::X(const X&), got %d\n",
+               "of UserClass::UserClass(const UserClass&), got %d\n",
                __LINE__, funcall, expect_copy, n_copy);
 
     rw_assert (n_asgn == int (expect_asgn), 0, line,
                "line %d: %s: expected %zu invocations "
-               "of X::operator=(const X&), got %d\n",
+               "of UserClass::operator=(const UserClass&), got %d\n",
                __LINE__, funcall, expect_asgn, n_asgn);
 
     // Free funcall storage
@@ -972,7 +984,7 @@
 template <class Iterator>
 void test_assign_range (const Iterator &it, const char* itname)
 {
-    rw_info (0, 0, 0, "std::deque<X>::assign(%s, %s)", itname, itname);
+    rw_info (0, 0, 0, "std::deque<UserClass>::assign(%s, %s)", itname, itname);
 
     static const char seq[] = "abcdefghijklmnopqrstuvwxyz";
     static const char asn[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -992,7 +1004,8 @@
     // exercise
     //   deque::assign(size_type, const_reference)
 
-    rw_info (0, 0, 0, "std::deque<X>::assign(size_type, const_reference)");
+    rw_info (0, 0, 0,
+             "std::deque<UserClass>::assign(size_type, const_reference)");
 
     static const char seq[] = "abcdefghijklmnopqrstuvwxyz";
     static const char res[] = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
@@ -1000,7 +1013,8 @@
     for (std::size_t i = 0; i != sizeof seq - 1; ++i) {
         for (std::size_t j = 0; j != sizeof seq - 1; ++j) {
 
-            test_assign (__LINE__, -1, (X*)0, int (j), seq, i, res, 1U, res, j);
+            test_assign (__LINE__, -1, (UserClass*)0, int (j),
+                         seq, i, res, 1U, res, j);
         }
     }
 
@@ -1011,39 +1025,41 @@
 
     rw_info (0, 0, 0, 
              "template <class InputIterator> "
-             "std::deque<X>::assign(InputIterator, InputIterator)");
+             "std::deque<UserClass>::assign(InputIterator, InputIterator)");
 
     if (0 == rw_opt_no_input_iterator)
-        test_assign_range (InputIter<X>(0, 0, 0), "InputIter<X>");
+        test_assign_range (InputIter<UserClass>(0, 0, 0),
+                           "InputIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::assign(T, T) [with T = InputIterator]"
+                 "std::deque<UserClass>::assign(T, T) [with T = InputIterator]"
                  "test disabled.");
 
     if (0 == rw_opt_no_forward_iterator)
-        test_assign_range (FwdIter<X>(), "FwdIter<X>");
+        test_assign_range (FwdIter<UserClass>(), "FwdIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::assign(T, T) [with T = ForwardIterator]"
-                 "test disabled.");
+                 "std::deque<UserClass>::assign(T, T) "
+                 "[with T = ForwardIterator] test disabled.");
 
     if (0 == rw_opt_no_bidirectional_iterator)
-        test_assign_range (BidirIter<X>(), "BidirIter<X>");
+        test_assign_range (BidirIter<UserClass>(), "BidirIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::assign(T, T) [with T = BidirectionalIterator]"
-                 "test disabled.");
+                 "std::deque<UserClass>::assign(T, T) "
+                 "[with T = BidirectionalIterator] test disabled.");
 
     if (0 == rw_opt_no_random_iterator)
-        test_assign_range (RandomAccessIter<X>(), "RandomAccessIter<X>");
+        test_assign_range (RandomAccessIter<UserClass>(),
+                           "RandomAccessIter<UserClass>");
     else 
         rw_note (0, 0, __LINE__, 
                  "template <class T> "
-                 "std::deque<X>::assign(T, T) [with T = RandomAccessIterator]"
-                 "test disabled.");
+                 "std::deque<UserClass>::assign(T, T) "
+                 "[with T = RandomAccessIterator] test disabled.");
 }
 
 /**************************************************************************/
@@ -1053,13 +1069,13 @@
                  std::size_t begoff, std::size_t len,
                  const char *res, std::size_t reslen)
 {
-    const X* const xseq = X::from_char (seq, seqlen + 1);
+    const UserClass* const xseq = UserClass::from_char (seq, seqlen + 1);
 
     Deque deq = seqlen ? Deque (xseq, xseq + seqlen) : Deque ();
     const Deque::iterator start = deq.begin () + begoff;
  
-    int n_copy = X::n_total_copy_ctor_;
-    int n_asgn = X::n_total_op_assign_;
+    int n_copy = UserClass::n_total_copy_ctor_;
+    int n_asgn = UserClass::n_total_op_assign_;
 
     char* funcall = 0;
     std::size_t buflen = 0;
@@ -1073,7 +1089,7 @@
                       begoff == deq.size (), begoff, begoff);
         
         exception_loop (line, Erase_1, funcall, 0,
-                        deq, start, 1, 0, (X*)0, (X*)0,
+                        deq, start, 1, 0, (UserClass*)0, (UserClass*)0,
                         &n_copy, &n_asgn);
     }
     else {   // assign(size_type, const_reference)
@@ -1093,7 +1109,7 @@
                       end - deq.begin ());
         
         exception_loop (line, EraseRange, funcall, 0,
-                        deq, start, len, 0, (X*)0, (X*)0,
+                        deq, start, len, 0, (UserClass*)0, (UserClass*)0,
                         &n_copy, &n_asgn);
 
     }
@@ -1151,12 +1167,12 @@
 
     rw_assert (n_copy == int (expect_copy), 0, line,
                "line %d: %s: expected %zu invocations "
-               "of X::X(const X&), got %d\n",
+               "of UserClass::UserClass(const UserClass&), got %d\n",
                __LINE__, funcall, expect_copy, n_copy);
 
     rw_assert (n_asgn == int (expect_asgn), 0, line,
                "line %d: %s: expected %zu invocations "
-               "of X::operator=(const X&), got %d\n",
+               "of UserClass::operator=(const UserClass&), got %d\n",
                __LINE__, funcall, expect_asgn, n_asgn);
 #endif
 
@@ -1170,7 +1186,7 @@
     //////////////////////////////////////////////////////////////////
     // exercise deque::erase(iterator)
 
-    rw_info (0, 0, 0, "std::deque<X>::erase(iterator)");
+    rw_info (0, 0, 0, "std::deque<UserClass>::erase(iterator)");
 
 #undef TEST
 #define TEST(seq, off, res) do {                        \
@@ -1228,7 +1244,7 @@
     //////////////////////////////////////////////////////////////////
     // exercise deque::erase(iterator, iterator)
 
-    rw_info (0, 0, 0, "std::deque<X>::erase(iterator, iterator)");
+    rw_info (0, 0, 0, "std::deque<UserClass>::erase(iterator, iterator)");
 }
 
 /**************************************************************************/
@@ -1274,14 +1290,14 @@
     // *  If the constructor
     //
     //    template <class InputIterator>
-    //    X (InputIterator f, InputIterator l,
+    //    UserClass (InputIterator f, InputIterator l,
     //       const allocator_type& a = allocator_type())
     //
     //    is called with a type InputIterator that does not qualify
     //    as an input iterator, then the constructor will behave
     //    as if the overloaded constructor:
     //
-    //    X (size_type, const value_type& = value_type(),
+    //    UserClass (size_type, const value_type& = value_type(),
     //       const allocator_type& = allocator_type())
     //
     //    were called instead, with the arguments static_cast<size_type>(f),
@@ -1311,8 +1327,8 @@
     //    were called instead, with the same arguments.
     //
     // In the previous paragraph the alternative binding will fail
-    // if f is not implicitly convertible to X::size_type or
-    // if l is not implicitly convertible to X::value_type.
+    // if f is not implicitly convertible to UserClass::size_type or
+    // if l is not implicitly convertible to UserClass::value_type.
     //
     // The extent to which an implementation determines that a type
     // cannot be an input iterator is unspecified, except that
@@ -1362,7 +1378,7 @@
         new_capacity = caps [i];
 
         rw_info (0, 0, 0, 
-                 "__rw::__rw_new_capacity<std::deque<X> >(0) = %zu",
+                 "__rw::__rw_new_capacity<std::deque<UserClass> >(0) = %zu",
                  _RW::__rw_new_capacity (0, (Deque*)0));
 
         if (0 == rw_opt_no_assign)

Modified: incubator/stdcxx/trunk/tests/containers/23.deque.special.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/containers/23.deque.special.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.deque.special.cpp (original)
+++ incubator/stdcxx/trunk/tests/containers/23.deque.special.cpp Wed Feb 21 07:58:53 2007
@@ -6,16 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
- * Software division. Licensed 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.
+ * 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 1994-2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -23,7 +30,7 @@
 
 #include <cstddef>      // for size_t
 
-#include <alg_test.h>   // for X
+#include <rw_value.h>   // for UserClass
 #include <driver.h>     // for rw_test(), ...
 
 /**************************************************************************/
@@ -76,7 +83,7 @@
 
 /**************************************************************************/
 
-typedef std::deque<X, std::allocator<X> > Deque;
+typedef std::deque<UserClass, std::allocator<UserClass> > Deque;
 
 Deque::size_type new_capacity;
 
@@ -231,7 +238,7 @@
 void test_swap ()
 {
     test_swap ((int*)0, "int");
-    test_swap ((X*)0, "X");
+    test_swap ((UserClass*)0, "UserClass");
 }
 
 /**************************************************************************/
@@ -250,7 +257,7 @@
         new_capacity = caps [i];
 
         rw_info (0, 0, 0, 
-                 "__rw::__rw_new_capacity<std::deque<X> >(0) = %u",
+                 "__rw::__rw_new_capacity<std::deque<UserClass> >(0) = %u",
                  _RW::__rw_new_capacity (0, (Deque*)0));
 
         test_swap ();

Modified: incubator/stdcxx/trunk/tests/containers/23.vector.capacity.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/containers/23.vector.capacity.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.vector.capacity.cpp (original)
+++ incubator/stdcxx/trunk/tests/containers/23.vector.capacity.cpp Wed Feb 21 07:58:53 2007
@@ -6,22 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright 2006 The Apache Software Foundation or its licensors,
- * as applicable.
+ * 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
  *
- * Copyright 2006 Rogue Wave Software.
- *
- * Licensed 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
+ * 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.
+ * 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 2006 Rogue Wave Software.
  *
  **************************************************************************/
 
@@ -29,6 +30,7 @@
 #include <vector>      // for vector
 
 #include <alg_test.h>
+#include <rw_value.h>  // for UserClass
 #include <driver.h>
 
 /**************************************************************************/
@@ -38,7 +40,7 @@
 
 /**************************************************************************/
 
-typedef std::vector<X, std::allocator<X> > Vector;
+typedef std::vector<UserClass, std::allocator<UserClass> > Vector;
 
 // exercise vector<>::capacity() and vector<>::reserve()
 // focus on the complexity of the function
@@ -51,21 +53,21 @@
     const Vector::size_type     size  = v.size ();
           Vector::const_pointer begin = size ? &v [0] : 0;
 
-    X::reset_totals ();
+    UserClass::reset_totals ();
 
     // call reserve capacity that is less than or equal to the current value
     v.reserve (cap / 2);
 
     // verify that the call had no effect
     rw_assert (v.capacity () == cap, 0, __LINE__,
-               "vector<X>(%zu).reserve(%zu); capacity() == %zu, got %zu",
-               nelems, cap / 2, cap, v.capacity ());
+               "vector<UserClass>(%zu).reserve(%zu); capacity() == %zu, "
+               "got %zu", nelems, cap / 2, cap, v.capacity ());
 
     if (size) {
         // verify that no reallocation took place
         rw_assert (begin == &v [0], 0, __LINE__,
-                   "vector<X>(%zu).reserve(%zu) unexpectedly reallocated",
-                   nelems, cap / 2);
+                   "vector<UserClass>(%zu).reserve(%zu) unexpectedly "
+                   "reallocated", nelems, cap / 2);
     }
 
     // call reserve the same capacity as the current value
@@ -73,14 +75,14 @@
 
     // verify that the call had no effect
     rw_assert (v.capacity () == cap, 0, __LINE__,
-               "vector<X>(%zu).reserve(%zu); capacity() == %zu, got %zu",
-               nelems, cap / 2, cap, v.capacity ());
+               "vector<UserClass>(%zu).reserve(%zu); capacity() == %zu, "
+               "got %zu", nelems, cap / 2, cap, v.capacity ());
 
     if (size) {
         // verify that no reallocation took place
         rw_assert (begin == &v [0], 0, __LINE__,
-                   "vector<X>(%zu).reserve(%zu) unexpectedly reallocated",
-                   nelems, cap / 2);
+                   "vector<UserClass>(%zu).reserve(%zu) unexpectedly "
+                   "reallocated", nelems, cap / 2);
     }
 
     // call reserve with a larger capacity then is available
@@ -89,19 +91,19 @@
     // 23.2.4.2, p2: After reserve (), capacity () is greater or equal
     //               to the reserve value if reallocation happens
     rw_assert (v.capacity () >= cap + 1, 0, __LINE__,
-               "vector<X>(%zu).reserve(%zu); capacity() > %zu, got %zu",
+               "vector<UserClass>(%zu).reserve(%zu); capacity() > %zu, got %zu",
                nelems, cap + 1, cap, v.capacity ());
 
     // 23.2.3.2, p3: reserve shall not change the size of the sequence
     rw_assert (v.size () == size, 0, __LINE__,
-               "vector<X>(%zu).reserve(); size() == %zu, got %zu",
+               "vector<UserClass>(%zu).reserve(); size() == %zu, got %zu",
                nelems, size, v.size ());
 
     // 23.2.3.2, p3: takes at most linear time in the size of the sequence
-    rw_assert (X::n_total_copy_ctor_ == v.size (), 0, __LINE__,
-               "vector<X>(%zu).reserve(%zu) complexity: "
+    rw_assert (UserClass::n_total_copy_ctor_ == v.size (), 0, __LINE__,
+               "vector<UserClass>(%zu).reserve(%zu) complexity: "
                "copy ctor called %zu times when size() = %zu",
-               nelems, cap + 1, X::n_total_copy_ctor_, v.size ());
+               nelems, cap + 1, UserClass::n_total_copy_ctor_, v.size ());
 
     if (size) {
         begin = &v [0];
@@ -109,11 +111,11 @@
         // verify 23.2.4.2, p5: no reallocation takes place until
         // the size of the container would exceed its capacity
         for (Vector::size_type i = 0; i != v.capacity () - size; ++i) {
-            v.push_back (X ());
+            v.push_back (UserClass ());
 
             rw_assert (begin == &v [0], 0, __LINE__,
-                       "vector<X>(%zu).reserve(%zu); insertion of element "
-                       "%zu unexpectedly reallocated; size() = %zu",
+                       "vector<UserClass>(%zu).reserve(%zu); insertion of "
+                       "element %zu unexpectedly reallocated; size() = %zu",
                        nelems, cap + 1, v.size ());
         }
     }
@@ -142,12 +144,14 @@
     }
 
     rw_assert (0 != caught, 0, __LINE__,
-               "vector<X>(%zu).reserve(%zu) expected exception not thrown",
+               "vector<UserClass>(%zu).reserve(%zu) "
+               "expected exception not thrown",
                nelems, too_much);
 
     if (caught)
         rw_assert ('\0' == *caught, 0, __LINE__,
-                   "vector<X>(%zu).reserve(%zu) expected length_error, got %s",
+                   "vector<UserClass>(%zu).reserve(%zu) "
+                   "expected length_error, got %s",
                    nelems, too_much, caught);
 
 #endif // _RWSTD_NO_EXCEPTIONS
@@ -159,8 +163,8 @@
 static int
 run_test (int /* argc */, char** /* argv */)
 {
-    rw_info (0, 0, 0, "std::vector<X>::capacity() const");
-    rw_info (0, 0, 0, "std::vector<X>::reserve(size_type)");
+    rw_info (0, 0, 0, "std::vector<UserClass>::capacity() const");
+    rw_info (0, 0, 0, "std::vector<UserClass>::reserve(size_type)");
 
     const Vector::size_type max_elems = Vector::size_type (rw_opt_nloops);
 

Modified: incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp?view=diff&rev=510071&r1=510070&r2=510071
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp (original)
+++ incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp Wed Feb 21 07:58:53 2007
@@ -6,22 +6,23 @@
  *
  ***************************************************************************
  *
- * Copyright 2006 The Apache Software Foundation or its licensors,
- * as applicable.
+ * 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
  *
- * Copyright 2006 Rogue Wave Software.
- *
- * Licensed 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
+ * 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.
+ * 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 2006 Rogue Wave Software.
  * 
  **************************************************************************/
 
@@ -31,6 +32,7 @@
 #include <cstddef>     // for size_t
 
 #include <alg_test.h>
+#include <rw_value.h>  // for UserClass
 #include <driver.h>
 #include <rw_new.h>
 
@@ -296,33 +298,33 @@
 // focus on the correct construction and destruction of values
 void test_ctors ()
 {
-    typedef std::vector<X, std::allocator<X> > Vector;
+    typedef std::vector<UserClass, std::allocator<UserClass> > Vector;
 
     if (1) {
 
         rw_info (0, 0, 0,
-                 "std::vector<X>::vector(size_type, "
+                 "std::vector<UserClass>::vector(size_type, "
                  "const_reference, const allocator_type&)");
 
-        rw_info (0, 0, 0, "std::vector<X>::vector(const vector&)");
+        rw_info (0, 0, 0, "std::vector<UserClass>::vector(const vector&)");
 
         // reset function call counters
-        X::reset_totals ();
+        UserClass::reset_totals ();
 
-        // total number of objects of type X in existence
-        const std::size_t x_count = X::count_;
+        // total number of objects of type UserClass in existence
+        const std::size_t x_count = UserClass::count_;
 
         for (Vector::size_type i = 0; i != rw_opt_nloops; ++i) {
 
-            rw_assert (X::count_ == x_count, 0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference); "
+            rw_assert (UserClass::count_ == x_count, 0, __LINE__,
+                       "vector<UserClass>::vector(size_type, const_reference); "
                        "leaked %zu objects of value_type",
-                       X::count_ - x_count);
+                       UserClass::count_ - x_count);
 
             // reset function call counters
-            X::reset_totals ();
+            UserClass::reset_totals ();
 
-            const X val;
+            const UserClass val;
 
             // initialize a vector with `i' copies of `val'
             const Vector v0 (i, val);
@@ -330,17 +332,17 @@
                        && v0.begin ()  + i  == v0.end ()
                        && v0.rbegin () + i  == v0.rend (),
                        0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference)");
+                       "vector<UserClass>::vector(size_type, const_reference)");
 
             // verify that the vector ctor calls only copy ctor
-            // of X and anly the given number of times each
-            rw_assert (X::is_total (i + 1, 1, i, 0, 0, 0), 0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference); "
+            // of UserClass and anly the given number of times each
+            rw_assert (UserClass::is_total (i + 1, 1, i, 0, 0, 0), 0, __LINE__,
+                       "vector<UserClass>::vector(size_type, const_reference); "
                        "called default/copy ctor and operator=() %zu, %zu, "
                        "and %zu times, respectively, 0, %zu, 0 expected",
-                       X::n_total_def_ctor_ - 1,
-                       X::n_total_copy_ctor_,
-                       X::n_total_op_assign_, i);
+                       UserClass::n_total_def_ctor_ - 1,
+                       UserClass::n_total_copy_ctor_,
+                       UserClass::n_total_op_assign_, i);
 
             // create a copy
             Vector v1 (v0);
@@ -348,18 +350,18 @@
                        && v1.begin  () + i == v1.end ()
                        && v1.rbegin () + i == v1.rend (),
                        0, __LINE__,
-                       "vector<X>::vector(const vector&)");
+                       "vector<UserClass>::vector(const vector&)");
 
             // verify that the vector copy ctor calls only copy ctor
-            // of X and anly the given number of times each
-            rw_assert (X::is_total (2 * i + 1, 1, 2 * i, 0, 0, 0),
+            // of UserClass and anly the given number of times each
+            rw_assert (UserClass::is_total (2 * i + 1, 1, 2 * i, 0, 0, 0),
                        0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference); "
+                       "vector<UserClass>::vector(size_type, const_reference); "
                        "called default/copy ctor and operator=() %zu, %zu, "
                        "and %zu times, respectively, 0, %zu, 0 expected",
-                       X::n_total_def_ctor_ - 1,
-                       X::n_total_copy_ctor_,
-                       X::n_total_op_assign_, i);
+                       UserClass::n_total_def_ctor_ - 1,
+                       UserClass::n_total_copy_ctor_,
+                       UserClass::n_total_op_assign_, i);
 
             // exercise vector<>operator=(const vector&)
             Vector v2 (i, val);
@@ -371,10 +373,12 @@
                 // assign a vector (of a possibly unequal size)
                 v3 = v2;
                 rw_assert (v3.size () == v2.size (), 0, __LINE__,
-                           "%zu. vector<X>::operator=(const vector&)", j);
+                           "%zu. vector<UserClass>::operator=(const vector&)",
+                           j);
 
                 rw_assert (v3 == v2, 0, __LINE__,
-                           "%zu. vector<X>::operator=(const vector&)", j);
+                           "%zu. vector<UserClass>::operator=(const vector&)",
+                           j);
             }
 
 #ifndef _RWSTD_NO_EXCEPTIONS
@@ -390,12 +394,13 @@
                 char buf [sizeof (Vector)];
             } buf = { 0 };
 
-            std::size_t x_count_save = X::count_;
+            std::size_t x_count_save = UserClass::count_;
 
             try {
-                // have X copy ctor throw an exception during
+                // have UserClass copy ctor throw an exception during
                 // the copying of the last value
-                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + i;
+                UserClass::copy_ctor_throw_count_ =
+                    UserClass::n_total_copy_ctor_ + i;
 
                 // create a vector object, throw an exception
                 // expect vector ctor to destroy any values
@@ -427,19 +432,20 @@
             rw_assert (i == 0 || thrown, 0, __LINE__,
                        "logic error: failed to throw");
 
-            rw_assert (x_count_save == X::count_, 0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference) "
+            rw_assert (x_count_save == UserClass::count_, 0, __LINE__,
+                       "vector<UserClass>::vector(size_type, const_reference) "
                        "leaked %zu value(s) of %zu after an exception",
-                       X::count_ - x_count_save, i);
+                       UserClass::count_ - x_count_save, i);
 
             // exercise vector<>::vector(const vector&)
             thrown       = false;
-            x_count_save = X::count_;
+            x_count_save = UserClass::count_;
 
             try {
-                // have X copy ctor throw an exception during
+                // have UserClass copy ctor throw an exception during
                 // the copying of the last value
-                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + i;
+                UserClass::copy_ctor_throw_count_ =
+                    UserClass::n_total_copy_ctor_ + i;
 
                 // use placement new to prevent vector destruction
                 // at scope exit (the object should be destroyed
@@ -467,14 +473,14 @@
             rw_assert(i == 0 || thrown, 0, __LINE__,
                       "logic error: failed to throw");
 
-            rw_assert (x_count_save == X::count_, 0, __LINE__,
-                       "vector<X>::vector(const vector&) leaked "
+            rw_assert (x_count_save == UserClass::count_, 0, __LINE__,
+                       "vector<UserClass>::vector(const vector&) leaked "
                        "%zu value(s) of %zu after an exception",
-                       X::count_ - x_count_save, i);
+                       UserClass::count_ - x_count_save, i);
 
 
             // disable exceptions
-            X::copy_ctor_throw_count_ = std::size_t (-1);
+            UserClass::copy_ctor_throw_count_ = std::size_t (-1);
 
             // remember v1's size and capacity
             const Vector::size_type v1_size = v1.size ();
@@ -488,12 +494,13 @@
 
             // exrecise vector<>::operator=(const vector&)
             thrown       = false;
-            x_count_save = X::count_;
+            x_count_save = UserClass::count_;
 
             try {
-                // have X copy ctor throw an exception during
+                // have UserClass copy ctor throw an exception during
                 // the copying of the last value
-                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + v3.size ();
+                UserClass::copy_ctor_throw_count_ =
+                    UserClass::n_total_copy_ctor_ + v3.size ();
 
                 // assign over the existing elements, the last copy ctor or
                 // operator=() throws, destroying all values assigned so far
@@ -505,22 +512,23 @@
             }
 
             // disable exceptions
-            X::copy_ctor_throw_count_ = std::size_t (-1);
+            UserClass::copy_ctor_throw_count_ = std::size_t (-1);
 
             rw_assert (i == 0 || thrown, 0, __LINE__,
                        "logic error: failed to throw");
 
             // verify that no values leaked
-            rw_assert (x_count_save == X::count_, 0, __LINE__,
-                       "vector<X>::vector(const vector&) leaked "
+            rw_assert (x_count_save == UserClass::count_, 0, __LINE__,
+                       "vector<UserClass>::vector(const vector&) leaked "
                        "%zu value(s) of %zu after an exception",
-                       X::count_ - x_count_save, i);
+                       UserClass::count_ - x_count_save, i);
 
             // verify that the size of the left hand size operand
             // of the assignment hasn't changed
             rw_assert (v1.size () == v1_size && v1.capacity () == v1_cap,
-                       0, __LINE__, "vector<X>::operator=(const vector&) "
-                       "changed size of *this from %zu to %zu after exception",
+                       0, __LINE__, "vector<UserClass>::operator="
+                       "(const vector&) changed size of *this from "
+                       "%zu to %zu after exception",
                        i / 2, v3.size ());
 
 #endif   // _RWSTD_NO_EXCEPTIONS
@@ -536,7 +544,8 @@
 {
     if (1) {
 
-        rw_info (0, 0, 0, "std::vector<X>::vector(const allocator_type&)");
+        rw_info (0, 0, 0,
+                 "std::vector<UserClass>::vector(const allocator_type&)");
 
         // verify default ctor arguments
         Vector v0;
@@ -545,18 +554,18 @@
         rw_assert (   0 == v0.size ()
                    && v0.empty () && v0.begin () == v0.end ()
                    && v0.rbegin () == v0.rend (), 0, __LINE__,
-                      ("vector<X>::vector()"));
+                      ("vector<UserClass>::vector()"));
 
         rw_assert (   0 == v1.size ()
                    && v1.empty () && v1.begin () == v1.end ()
                    && v1.rbegin () == v1.rend (), 0, __LINE__,
-                      "vector<X>::vector()");
+                      "vector<UserClass>::vector()");
     }
 
     if (1) {
 
         rw_info (0, 0, 0,
-                 "std::vector<X>::vector(size_type, "
+                 "std::vector<UserClass>::vector(size_type, "
                  "const_reference, const allocator_type&)");
 
         for (typename Vector::size_type i = 0; i != rw_opt_nloops; ++i) {
@@ -570,14 +579,15 @@
                        && v0.begin  () + i == v0.end ()
                        && v0.rbegin () + i == v0.rend (),
                           0, __LINE__,
-                          "vector<X>::vector(size_type, const_reference)");
+                          "vector<UserClass>::vector"
+                          "(size_type, const_reference)");
 
             rw_assert (   i == v1.size ()
                        && v1.begin  () + i == v1.end ()
                        && v1.rbegin () + i == v1.rend (),
                           0, __LINE__,
-                          "vector<X>::vector(size_type, const_reference, "
-                          "const allocator_type&)");
+                          "vector<UserClass>::vector(size_type, "
+                          "const_reference, const allocator_type&)");
 
             bool success = true;
             for (typename Vector::size_type j = 0; j != i; ++j) {
@@ -588,7 +598,7 @@
             }
 
             rw_assert (success, 0, __LINE__,
-                       "vector<X>::vector(size_type, const_reference); "
+                       "vector<UserClass>::vector(size_type, const_reference); "
                        "all elements initialized");
         }
     }
@@ -599,7 +609,7 @@
     if (1) {
 
         rw_info (0, 0, 0,
-                 "template <class InputIterator> std::vector<X>::vector "
+                 "template <class InputIterator> std::vector<UserClass>::vector"
                  "(InputIterator, InputIterator)");
 
         bool success = true;
@@ -649,7 +659,8 @@
 
         rw_assert (success, 0, __LINE__,
                    "template <class InputIterator> "
-                   "std::vector<X>::vector(InputIterator, InputIterator)");
+                   "std::vector<UserClass>::vector"
+                   "(InputIterator, InputIterator)");
 
         // destroy and deallocate...
         for (typename Vector::size_type j = 0; j != rw_opt_nloops; ++j)



Mime
View raw message