stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r370230 - /incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp
Date Wed, 18 Jan 2006 19:38:52 GMT
Author: sebor
Date: Wed Jan 18 11:38:48 2006
New Revision: 370230

URL: http://svn.apache.org/viewcvs?rev=370230&view=rev
Log:
2006-01-18  Anton Pevtsov <antonp@moscow.vdiweb.com>
	    Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 25.swap.cpp: New test exercising lib.alg.swap.

Added:
    incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp?rev=370230&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp (added)
+++ incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp Wed Jan 18 11:38:48 2006
@@ -0,0 +1,376 @@
+/***************************************************************************
+ *
+ * 25.swap.cpp - test exercising 25.2.2 [lib.alg.swap]
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * 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.
+ * 
+ **************************************************************************/
+
+#include <algorithm>    // for swap, swap_ranges, iter_swap
+#include <cstring>      // for size_t, strlen()
+
+#include <alg_test.h>
+#include <driver.h>     // for rw_test()
+
+
+_RWSTD_NAMESPACE (std) { 
+
+// disable explicit instantiation for compilers (like MSVC)
+// that can't handle it
+#ifndef _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+template
+void
+swap (assign<base<cpy_ctor> >&, assign<base<cpy_ctor> >&);
+
+template
+FwdIter<assign<base<cpy_ctor> > >
+swap_ranges (FwdIter<assign<base<cpy_ctor> > >, 
+             FwdIter<assign<base<cpy_ctor> > >, 
+             FwdIter<assign<base<cpy_ctor> > >);
+
+template
+void
+iter_swap (FwdIter<assign<base<cpy_ctor> > >, 
+           FwdIter<assign<base<cpy_ctor> > >);
+
+#endif // _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+}   // namespace std
+
+/**************************************************************************/
+
+template <class T, class ForwardIterator1, class ForwardIterator2>
+void test_iter_swap (int line,
+                     const char*      seq, 
+                     ForwardIterator1 /* dummy */,
+                     ForwardIterator2 /* dummy */,
+                     const T*         /* dummy */,
+                     bool             it_swap,
+                     const char*      it1name,
+                     const char*      it2name,
+                     const char*      fname)
+{
+    // generate sequential values for each default constructed T 
+    const std::size_t nseq = std::strlen (seq);
+
+    // construct a sequence of `nseq' elements to pass to swap
+    T* const tseq = T::from_char (seq, nseq + 1);
+
+    int a_val, b_val;
+    bool success = true;
+    std::size_t i = 1;
+    for ( ; i < nseq; ++i) {
+
+        const ForwardIterator1 it1 = 
+            make_iter (tseq, tseq, tseq + nseq, it1);
+
+        const ForwardIterator2 it2 = 
+            make_iter (tseq + i, tseq, tseq + nseq, it2);
+
+        a_val = (*it1).val_;
+        b_val = (*it2).val_;
+
+        it_swap ? std::iter_swap (it1, it2) : std::swap(*it1, *it2);
+
+        // verify 25.2.2, p2, p7
+        success = a_val == (*it2).val_ && b_val == (*it1).val_;
+        if (!success)
+            break;
+    }
+
+    rw_assert (success, 0, line,
+               "%s<%s%{?}, %s%{;}>(%#c, %#c): got: { %#c, %#c } "
+               "expected: { %5$#c, %4$#c } at step %zu",
+               fname, it1name, it_swap, it2name, a_val, b_val, tseq->val_, 
+               (tseq + i)->val_, i);
+
+    delete[] tseq;
+}
+
+template <class T, class ForwardIterator1, class ForwardIterator2>
+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 fname   = it_swap ? "iter_swap" : "swap";
+
+    rw_info (0, 0, 0, "std::%s (%s, %s)", fname, it1name, it2name);
+
+#undef TEST
+#define TEST(seq)                                               \
+    test_iter_swap (__LINE__, seq, it1, it2, (T*)0, it_swap,    \
+                    it1name, it2name, fname)
+
+    TEST("ab");
+    TEST("abc");
+    TEST("abcd");
+    TEST("abcde");
+    TEST("abcdef");
+    TEST("abcdefg");
+    TEST("abcdefgh");
+    TEST("abcdefghi");
+    TEST("abcdefghij");
+    TEST("abcdefghijk");
+}
+
+/**************************************************************************/
+
+template <class T, class ForwardIterator1, class ForwardIterator2>
+void test_swap_ranges (int              line,
+                       const char*      seq1,
+                       const char*      seq2, 
+                       ForwardIterator1 it1, 
+                       ForwardIterator2 it2,
+                       const T*         /* dummy */,
+                       const char*      it1name,
+                       const char*      it2name)
+{
+    const std::size_t nseq = std::strlen (seq1);
+
+    // construct a sequence of `nseq' elements to pass to swap_ranges
+    T* const tseq1 = T::from_char (seq1, nseq + 1);
+    T* const tseq2 = T::from_char (seq2, nseq + 1);
+
+    const ForwardIterator1 first1 =
+        make_iter (tseq1, tseq1, tseq1 + nseq, it1);
+    const ForwardIterator1 last1  = 
+        make_iter (tseq1 + nseq, tseq1, tseq1 + nseq, it1);
+    const ForwardIterator2 first2 = 
+        make_iter (tseq2, tseq2, tseq2 + nseq, it2);
+    const ForwardIterator2 last2 = 
+        make_iter (tseq2 + nseq, tseq2, tseq2 + nseq, it2);
+
+    // silence bogus EDG eccp remark #550-D: variable was set
+    // but never used
+    _RWSTD_UNUSED (last2);
+
+    T a, b;
+
+    std::size_t last_n_op_assign = T::n_total_op_assign_;
+
+    std::swap (a, b);
+
+    std::size_t assigns_per_swap = T::n_total_op_assign_ - last_n_op_assign;
+
+    last_n_op_assign = T::n_total_op_assign_;
+
+    // exercise 25.2.3 - std::swap_ranges()
+    const ForwardIterator2 res = std::swap_ranges(first1, last1, first2); 
+
+    // silence bogus EDG eccp remark #550-D: variable was set
+    // but never used
+    _RWSTD_UNUSED (res);
+
+    // check the returned value, 25.2.2 p5
+    bool success = res.cur_ == last2.cur_;
+    rw_assert (success, 0, line,
+               "swap_ranges<%s, %s>(\"%s\", \"%s\") == first + %td, "
+               "got first + %td",
+               it1name, it2name, seq1, seq2, res.cur_ - tseq2,
+               last2.cur_ - tseq2);
+
+    // check that the sequences were swapped, 25.2.2 p4
+    std::size_t i = 0;
+    for ( ; i < nseq; ++i) {
+        success = (tseq1 + i)->val_ == seq2[i] && (tseq2 + i)->val_ == seq1[i];
+        if (!success)
+            break;
+    }
+
+    rw_assert (success, 0, line, 
+               "swap_ranges<%s, %s>(\"%s\", \"%s\") mismatch at pos %zu "
+               "got { %#c, %#c }, expected { %#c, %#c }",
+               it1name, it2name, seq1, seq2, i,
+               (tseq1 + i)->val_, (tseq2 + i)->val_, seq2[i], seq1[i]);
+
+    // check the complexity, 25.2.2 p6
+    std::size_t swaps_per_swap_ranges =
+            (T::n_total_op_assign_ - last_n_op_assign) / assigns_per_swap;
+    rw_assert (swaps_per_swap_ranges == nseq, 0, line,
+               "swap_ranges<%s, %s>(\"%s\", \"%s\") complexity: "
+               "%zu, expected %zu swaps", 
+               it1name, it2name, seq1, seq2, swaps_per_swap_ranges, nseq);
+
+    delete[] tseq1;
+    delete[] tseq2;
+}
+
+/**************************************************************************/
+
+template <class T, class ForwardIterator1, class ForwardIterator2>
+void test_swap_ranges (ForwardIterator1 it1, 
+                       ForwardIterator2 it2,
+                       const T*         /* dummy */)
+{
+    static const char* const it1name = type_name (it1, (T*)0);
+    static const char* const it2name = type_name (it2, (T*)0);
+
+    rw_info (0, 0, 0, 
+             "std::swap_ranges (%s, %1$s, %s)",  it1name, it2name);
+
+#undef TEST
+#define TEST(seq1, seq2)                                       \
+    test_swap_ranges (__LINE__, seq1, seq2, it1, it2, (T*)0,   \
+                      it1name, it2name)
+
+    TEST("", "");
+    TEST("a", "z");
+    TEST("ab", "zy");
+    TEST("abc", "zyx");
+    TEST("abcd", "zyxw");
+    TEST("abcde", "zyxwv");
+    TEST("abcdef", "zyxwvu");
+    TEST("abcdefg", "zyxwvut");
+    TEST("abcdefgh", "zyxwvuts");
+    TEST("abcdefghi", "zyxwvutsr");
+    TEST("abcdefghij", "zyxwvutsrq");
+    TEST("abcdefghijk", "zyxwvutsrqp");
+    TEST("abcdefghijkl", "zyxwvutsrqpo");
+    TEST("abcdefghijklm", "zyxwvutsrqpon");
+}
+
+/**************************************************************************/
+
+/* extern */ int rw_opt_no_swap;             // --no-swap
+/* extern */ int rw_opt_no_swap_ranges;      // --no-swap_ranges
+/* extern */ int rw_opt_no_iter_swap;        // --no-iter_swap
+/* extern */ int rw_opt_no_fwd_iter;         // --no-ForwardIterator
+/* extern */ int rw_opt_no_bidir_iter;       // --no-BidirectionalIterator
+/* extern */ int rw_opt_no_rnd_iter;         // --no-RandomAccessIterator
+
+template <class T, class ForwardIterator1>
+void test_swap (ForwardIterator1 it1, const T*, bool test_ranges)
+{
+    if (rw_opt_no_fwd_iter) {
+        rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+    }
+    else {
+        if (test_ranges)
+            test_swap_ranges (it1, FwdIter<T>(), (T*)0);
+        else
+            test_iter_swap (it1, FwdIter<T>(), (T*)0, true);
+    }
+
+    if (rw_opt_no_bidir_iter) {
+        rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+    }
+    else {
+        if (test_ranges)
+            test_swap_ranges (it1, BidirIter<T>(), (T*)0);
+        else
+            test_iter_swap (it1, BidirIter<T>(), (T*)0, true);
+    }
+
+    if (rw_opt_no_rnd_iter) {
+        rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+    }
+    else {
+        if (test_ranges)
+            test_swap_ranges (it1, RandomAccessIter<T>(), (T*)0);
+        else
+            test_iter_swap (it1, RandomAccessIter<T>(), (T*)0, true);
+    }
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_swap (const T*, bool test_ranges)
+{
+    if (rw_opt_no_fwd_iter) {
+        rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+    }
+    else {
+        test_swap (FwdIter<T>(), (T*)0, test_ranges);
+    }
+
+    if (rw_opt_no_bidir_iter) {
+        rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+    }
+    else {
+        test_swap (BidirIter<T>(), (T*)0, test_ranges);
+    }
+
+    if (rw_opt_no_rnd_iter) {
+        rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+    }
+    else {
+        test_swap (RandomAccessIter<T>(), (T*)0, test_ranges);
+    }
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char*[])
+{
+    if (rw_opt_no_swap) {
+        rw_note (0, __FILE__, __LINE__,  "std::swap test disabled");
+    }
+    else {
+        rw_info (0, 0, 0, "template <class T> void swap (T&, T&)");
+
+        test_iter_swap (FwdIter<X>(), FwdIter<X>(), (X*)0, false);
+    }
+
+    if (rw_opt_no_swap_ranges) {
+        rw_note (0, __FILE__, __LINE__,  "std::swap_ranges test disabled");
+    }
+    else {
+        rw_info (0, 0, 0, 
+                 "template <class %s, class %s> %2$s "
+                 "swap_ranges (%1$s, %1$s, %2$s)",
+                 "ForwardIterator1", "ForwardIterator2");
+
+        test_swap ((X*)0, true);
+    }
+
+    if (rw_opt_no_iter_swap) {
+        rw_note (0, __FILE__, __LINE__,  "std::iter_swap test disabled");
+    }
+    else {
+        rw_info (0, 0, 0,
+                 "template <class %s, class %s> void iter_swap (%1$s, %2$s)",
+                 "ForwardIterator1", "ForwardIterator2");
+
+        test_swap ((X*)0, false);
+    }
+
+    return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.alg.swap",
+                    0 /* no comment */, run_test,
+                    "|-no-swap# "
+                    "|-no-swap_ranges# "
+                    "|-no-iter_swap# "
+                    "|-no-ForwardIterator# "
+                    "|-no-BidirectionalIterator# "
+                    "|-no-RandomAccessIterator",  
+                    &rw_opt_no_swap,
+                    &rw_opt_no_swap_ranges,
+                    &rw_opt_no_iter_swap,
+                    &rw_opt_no_fwd_iter,
+                    &rw_opt_no_bidir_iter,
+                    &rw_opt_no_rnd_iter);
+}

Propchange: incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/algorithms/25.swap.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message