stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r414917 - /incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp
Date Fri, 16 Jun 2006 21:18:20 GMT
Author: sebor
Date: Fri Jun 16 14:18:20 2006
New Revision: 414917

URL: http://svn.apache.org/viewvc?rev=414917&view=rev
Log:
2006-06-16  Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 20.specialized.cpp: New test exercising lib.specialized.algorithms,
	including STDCXX-203.

Added:
    incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp?rev=414917&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp (added)
+++ incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp Fri Jun 16 14:18:20 2006
@@ -0,0 +1,408 @@
+/***************************************************************************
+ *
+ * specialized.cpp - test exercising 20.4.4 [lib.specialized.algorithms]
+ *
+ * $Id: //stdlib/dev/tests/stdlib/utilities/specialized.cpp#2 $
+ *
+ ***************************************************************************
+ *
+ * Copyright 2005-2006 The Apache Software Foundation or its licensors,
+ * as applicable.
+ *
+ * Copyright 2001-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
+ *
+ * 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 <memory>
+#include <alg_test.h>
+#include <driver.h>
+
+/**************************************************************************/
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+struct Y
+{
+    static int count_;
+    static int ctor_;
+    static int dtor_;
+    static int throw_at_;
+
+    int val_;
+
+    Y (const Y &rhs) : val_ (rhs.val_) {
+        ++ctor_;
+        if (count_ + 1 == throw_at_)
+            throw 0;
+        ++count_;
+    }
+
+    Y (int val) : val_ (val) {
+        ++ctor_;
+        if (count_ + 1 == throw_at_)
+            throw 0;
+        ++count_;
+    }
+
+    ~Y () {
+        ++dtor_;
+        val_ = -2;
+        --count_;
+    }
+
+private:
+    void operator= (const Y&);   // not Assignable
+};
+
+
+int Y::count_;
+int Y::ctor_;
+int Y::dtor_;
+int Y::throw_at_;
+
+/**************************************************************************/
+
+template <class T>
+const char* type_name (volatile T*, T*) { return "volatile T*"; }
+
+template <class T>
+volatile T* make_iter (T *beg, T*, T*, volatile T*) { return beg; }
+
+/**************************************************************************/
+
+// exercises uninitialized_copy [lib.uninitialized.copy]
+// with emphasis on exception safety - the function is to have no effect
+// if an exception is thrown
+template <class InputIterator, class ForwardIterator>
+void test_uninitialized_copy (const InputIterator &dummy,
+                              const ForwardIterator*)
+{
+    const char* const i1name = type_name (InputIterator (0, 0, 0), (int*)0);
+    const char* const i2name = type_name (ForwardIterator (), (Y*)0);
+
+    rw_info (0, 0, __LINE__, "std::uninitialized_copy(%s, %1$s, %s)",
+             i1name, i2name);
+
+    static const int a[] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+    };
+
+    const unsigned N = sizeof a / sizeof *a;
+
+    // allocate an uninitialized buffer
+    Y *buf = _RWSTD_STATIC_CAST (Y*, ::operator new (N * sizeof (Y)));
+
+    for (unsigned i = 0; i != N; ++i) {
+
+        Y::count_ = Y::ctor_ = Y::dtor_ = 0;
+
+        // throw during the copy construction of the i-th elem
+        Y::throw_at_ = i;
+
+        try {
+            // constructs i elements, the last ctor throws
+            const InputIterator first =
+                make_iter (a, a, a + i, dummy);
+            const InputIterator last =
+                make_iter (a + i, a, a + i, first);
+
+            const ForwardIterator result =
+                make_iter (buf, buf, buf + i, ForwardIterator ());
+
+            std::uninitialized_copy (first, last, result);
+
+            rw_assert (i == 0, 0, __LINE__,
+                       "%zu. expected exception not thrown", i);
+        }
+        catch (int) {
+            // ctor throws an int, this is what's expected
+        }
+        catch (...) {
+            rw_assert (0, 0, __LINE__,
+                       "%zu. exception of an unexpected type thrown", i);
+        }
+
+        // verify that all constructed elements were destroyed
+        rw_assert (Y::count_ == 0, 0, __LINE__,
+                   "%zu. %d elements not destroyed", i, Y::count_);
+
+        // verify that the expected number of ctor and dtor calls were made
+        rw_assert (Y::ctor_ == Y::throw_at_, 0, __LINE__,
+                   "%zu. %d ctor calls expected, got %d",
+                   i, Y::throw_at_, Y::ctor_);
+        rw_assert (i ? Y::dtor_ + 1 == Y::throw_at_ : true, 0, __LINE__,
+                   "%zu. %d dtor calls expected, got %d",
+                   i, Y::throw_at_ - 1, Y::dtor_);
+    }
+
+    ::operator delete (buf);
+}
+
+/**************************************************************************/
+
+// exercises 20.4.4.2 and 3 - uninitialized_fill [lib.uninitialized.fill]
+// and uninitialized_fill_n [lib.uninitialized.fill_n] with emphasis on
+// exception safety - the function is to have no effect if an exception
+// is thrown
+template <class ForwardIterator>
+void test_uninitialized_fill (const ForwardIterator*, bool test_count)
+{
+    const char* const itname = type_name (ForwardIterator (), (Y*)0);
+
+    rw_info (0, 0, __LINE__,
+             "std::uninitialized_fill%{?}_n%{;}(%s, %{?}size_t%{:}%2$s%{;}, "
+             "const int&)", test_count, itname, test_count);
+
+    const unsigned N = 32;
+
+    // allocate an uninitialized buffer
+    Y *buf = _RWSTD_STATIC_CAST (Y*, ::operator new (N * sizeof (Y)));
+
+    for (unsigned i = 0; i != N; ++i) {
+
+        // prevent ctor below from throwing
+        Y::throw_at_ = -1;
+
+        // create a temporary and reset counters (in that order)
+        Y val (i);
+
+        Y::count_ = Y::ctor_ = Y::dtor_ = 0;
+
+        // throw during the copy construction of the i-th elem
+        Y::throw_at_ = i;
+
+        try {
+            // copy-constructs i elements, the last copy ctor throws
+            const ForwardIterator first =
+                make_iter (buf, buf, buf + i, ForwardIterator ());
+
+            if (test_count) {
+                std::uninitialized_fill_n (first, i, val);
+            }
+            else {
+                const ForwardIterator last =
+                    make_iter (buf + i, buf, buf + i, first);
+
+                std::uninitialized_fill (first, last, val);
+            }
+                
+            rw_assert (i == 0, 0, __LINE__,
+                       "%zu. expected exception not thrown", i);
+        }
+        catch (int) {
+            // ctor throws an int, this is what's expected
+        }
+        catch (...) {
+            rw_assert (0, 0, __LINE__,
+                       "%zu. exception of an unexpected type thrown", i);
+        }
+
+        // verify that all constructed elements were destroyed
+        rw_assert (Y::count_ == 0, 0, __LINE__,
+                   "%zu. %d elements not destroyed", i, Y::count_);
+
+        // verify that the expected number of ctor and dtor calls were made
+        rw_assert (Y::ctor_ == Y::throw_at_, 0, __LINE__,
+                   "%zu. %d ctor calls expected, got %d",
+                   i, Y::throw_at_, Y::ctor_);
+        rw_assert (i ? Y::dtor_ + 1 == Y::throw_at_ : true, 0, __LINE__,
+                   "%d. %d dtor calls expected, got %d",
+                   i, Y::throw_at_ - 1, Y::dtor_);
+    }
+
+    ::operator delete (buf);
+}
+
+/**************************************************************************/
+
+int opt_copy;
+int opt_fill;
+int opt_fill_n;
+
+int opt_input_iter;
+int opt_fwd_iter;
+int opt_bidir_iter;
+int opt_rnd_iter;
+int opt_volatile_ptr;
+
+
+template <class InputIterator>
+void test_uninitialized_copy (const InputIterator &dummy)
+{
+    if (-1 < opt_fwd_iter)
+        test_uninitialized_copy (dummy, (FwdIter<Y>*)0);
+    else
+        rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
+                 "ForwardIterator tests disabled");
+
+    if (-1 < opt_bidir_iter)
+        test_uninitialized_copy (dummy, (BidirIter<Y>*)0);
+    else
+        rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                 "BidirectionalIterator tests disabled");
+
+    if (-1 < opt_rnd_iter)
+        test_uninitialized_copy (dummy, (RandomAccessIter<Y>*)0);
+    else
+        rw_note (-1 > opt_rnd_iter--, 0, __LINE__,
+                 "RandomAccessIterator tests disabled");
+
+    if (-1 < opt_volatile_ptr) {
+        typedef volatile Y* VolatilePointer;
+        test_uninitialized_copy (dummy, (VolatilePointer*)0);
+    }
+    else
+        rw_note (-1 > opt_volatile_ptr--, 0, __LINE__,
+                 "volatile T* tests disabled");
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+    if (-1 < opt_copy) {
+        if (-1 < opt_input_iter)
+            test_uninitialized_copy (InputIter<int>(0, 0, 0));
+        else
+            rw_note (-1 > opt_input_iter--, 0, __LINE__,
+                     "InputIterator tests disabled");
+
+        if (-1 < opt_fwd_iter)
+            test_uninitialized_copy (ConstFwdIter<int>());
+        else
+            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
+                     "ForwardIterator tests disabled");
+    
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_copy (ConstBidirIter<int>());
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "BidirectionalIterator tests disabled");
+
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_copy (ConstRandomAccessIter<int>());
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "RandomAccessIterator tests disabled");
+    }
+    else
+        rw_note (0, 0, 0, "tests of std::uninitialized_copy disabled");
+
+    //////////////////////////////////////////////////////////////////
+
+    typedef volatile Y* VolatilePointer;
+
+    if (-1 < opt_fill) {
+        if (-1 < opt_fwd_iter)
+            test_uninitialized_fill ((FwdIter<Y>*)0, false);
+        else
+            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
+                     "ForwardIterator tests disabled");
+
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_fill ((BidirIter<Y>*)0, false);
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "BidirectionalIterator tests disabled");
+
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_fill ((RandomAccessIter<Y>*)0, false);
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "RandomAccessIterator tests disabled");
+
+        if (-1 < opt_volatile_ptr) {
+            test_uninitialized_fill ((VolatilePointer*)0, false);
+        }
+        else
+            rw_note (-1 > opt_volatile_ptr++,
+                     0, 0, "volatile T* tests disabled");
+    }
+    else
+        rw_note (0, 0, 0, "tests of std::uninitialized_fill disabled");
+
+    //////////////////////////////////////////////////////////////////
+    if (-1 < opt_fill) {
+        if (-1 < opt_fwd_iter)
+            test_uninitialized_fill ((FwdIter<Y>*)0, true);
+        else
+            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
+                     "ForwardIterator tests disabled");
+
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_fill ((BidirIter<Y>*)0, true);
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "BidirectionalIterator tests disabled");
+
+        if (-1 < opt_bidir_iter)
+            test_uninitialized_fill ((RandomAccessIter<Y>*)0, true);
+        else
+            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
+                     "RandomAccessIterator tests disabled");
+
+        if (-1 < opt_volatile_ptr) {
+            test_uninitialized_fill ((VolatilePointer*)0, true);
+        }
+        else
+            rw_note (-1 > opt_volatile_ptr--, 0, __LINE__,
+                     "volatile T* tests disabled");
+    }
+    else
+        rw_note (0, 0, 0, "tests of std::uninitialized_fill disabled");
+
+    return 0;
+}
+
+#else   // _RWSTD_NO_EXCEPTIONS
+
+static int
+run_test (int, char**)
+{
+    rw_note (0, 0, 0,
+             "exceptions disabled (_RWSTD_NO_EXCEPTIONS #defined), "
+             "cannot test");
+
+    return 0;
+}
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.specialized.algorithms",
+                    0 /* no comment */,
+                    run_test,
+                    "|-uninitialized_copy~ "
+                    "|-uninitialized_fill~ "
+                    "|-uninitialized_fill_n~ "
+                    "|-InputIterator~ "
+                    "|-ForwardIterator~ "
+                    "|-BidirectionalIterator~ "
+                    "|-RandomAccessIterator~ "
+                    "|-volatile-pointer",
+                    &opt_copy,
+                    &opt_fill,
+                    &opt_fill_n,
+                    &opt_input_iter,
+                    &opt_fwd_iter,
+                    &opt_bidir_iter,
+                    &opt_rnd_iter,
+                    &opt_volatile_ptr);
+}

Propchange: incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/utilities/20.specialized.cpp
------------------------------------------------------------------------------
    svn:keyword = Id



Mime
View raw message