stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r379235 - /incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp
Date Mon, 20 Feb 2006 20:52:59 GMT
Author: sebor
Date: Mon Feb 20 12:52:57 2006
New Revision: 379235

URL: http://svn.apache.org/viewcvs?rev=379235&view=rev
Log:
2006-02-20  Liviu Nicoara  <nicoara@roguewave.com>

	* 23.vector.cons.cpp: New test exercising lib.vector.cons.

Added:
    incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp?rev=379235&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp (added)
+++ incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp Mon Feb 20 12:52:57 2006
@@ -0,0 +1,796 @@
+/***************************************************************************
+ *
+ * 23.vector.cons.cpp - test exercising [lib.vector.cons]
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors,
+ * as applicable.
+ *
+ * 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
+ *
+ * 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>      // for placement operator new()
+#include <vector>      // for vector
+
+#include <cstddef>     // for size_t
+
+#include <alg_test.h>
+#include <driver.h>
+#include <rw_new.h>
+
+/**************************************************************************/
+
+static unsigned rw_opt_nloops;
+static int      rw_opt_no_int_spec;
+static int      rw_opt_no_short_spec;
+static int      rw_opt_no_types;
+static int      rw_opt_no_signatures;
+static int      rw_opt_no_ctors;
+
+/**************************************************************************/
+
+template <class RandomAccessIterator,
+          class T,
+          class Reference,
+          class Pointer,
+          class Difference>
+struct test_iterator
+{
+    test_iterator ();
+};
+
+/**************************************************************************/
+
+// outlined to prevent gcc -Winline warnings
+template <class RandomAccessIterator,
+          class T,
+          class Reference,
+          class Pointer,
+          class Difference>
+test_iterator<RandomAccessIterator, T, Reference, Pointer, Difference>::
+test_iterator ()
+{
+    static int i;   // zeroed out
+    if (++i)        // prevent "unreachable code" warnings
+        return;     // compile only
+
+    // exercise RandomAccessIterator requirements
+
+    RandomAccessIterator it = RandomAccessIterator ();
+    RandomAccessIterator it_cpy (it);
+
+    Difference d (it - it);
+
+    RandomAccessIterator &it_ref1 = ++it;
+    const RandomAccessIterator &it_ref2 = it++;
+
+    RandomAccessIterator &it_ref3 = --it;
+    const RandomAccessIterator &it_ref4 = it--;
+
+    RandomAccessIterator &it_ref5 = it += 1;
+    it_cpy = it + d;
+    it_cpy = d + it;
+
+    RandomAccessIterator &it_ref6 = it -= 1;
+    it_cpy = it - d;
+
+    T t (it [d]);
+
+    Reference ref1 (*it);
+    Reference ref2 (*it++);
+
+    bool b (it == it);
+    b = it != it;
+    b = it >  it;
+    b = it >= it;
+    b = it <= it;
+
+
+    _RWSTD_UNUSED (it);
+    _RWSTD_UNUSED (it_cpy);
+    _RWSTD_UNUSED (it_ref1);
+    _RWSTD_UNUSED (it_ref2);
+    _RWSTD_UNUSED (it_ref3);
+    _RWSTD_UNUSED (it_ref4);
+    _RWSTD_UNUSED (it_ref5);
+    _RWSTD_UNUSED (it_ref6);
+    _RWSTD_UNUSED (d);
+    _RWSTD_UNUSED (t);
+    _RWSTD_UNUSED (ref1);
+    _RWSTD_UNUSED (ref2);
+    _RWSTD_UNUSED (b);
+}
+
+/***************************************************************************/
+
+// verify that nested types are properly defined
+template <class Vector, class T, class Allocator>
+void test_types (Vector*, T*, Allocator)
+{
+#define TEST_TYPE(T, vectorT)   {              \
+        T *t = (typename Vector::vectorT*)0;   \
+        _RWSTD_UNUSED (t);                     \
+    }
+
+#define TEST_REFERENCE(T, vectorT)   {   \
+        typename Vector::value_type v;   \
+        T t = v;                         \
+        _RWSTD_UNUSED (t);               \
+    }
+
+    // verify nested types
+    TEST_TYPE (T,                                   value_type);
+    TEST_TYPE (Allocator,                           allocator_type);
+    TEST_TYPE (typename Allocator::pointer,         pointer);
+    TEST_TYPE (typename Allocator::const_pointer,   const_pointer);
+
+#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
+
+    typedef std::reverse_iterator<typename Vector::iterator>
+        ReverseIterator;
+    typedef std::reverse_iterator<typename Vector::const_iterator>
+      ConstReverseIterator;
+
+#else   // if defined (_RWSTD_NO_CLASS_PARTIAL_SPEC)
+
+    typedef std::reverse_iterator<typename Vector::iterator,
+        std::random_access_iterator_tag, T /*non-const T&, non-const T* */>
+      ReverseIterator;
+
+    typedef std::reverse_iterator<typename Vector::const_iterator,
+        std::random_access_iterator_tag, T, const T&, const T*>
+      ConstReverseIterator;
+
+#endif   // _RWSTD_NO_CLASS_PARTIAL_SPEC
+
+    TEST_TYPE (ReverseIterator, reverse_iterator);
+    TEST_TYPE (ConstReverseIterator, const_reverse_iterator);
+
+    test_iterator<typename Vector::iterator, T, T&, T*, std::ptrdiff_t>
+        ti;   // exercise iterator requirements
+    test_iterator<typename Vector::const_iterator, T, const T&, const T*,
+                  std::ptrdiff_t>
+        tci;   // exercise iterator requirements
+
+    test_iterator<ReverseIterator, T, T&, T*, std::ptrdiff_t>
+        tri;   // exercise iterator requirements
+    test_iterator<ConstReverseIterator, T, const T&, const T*, std::ptrdiff_t>
+        tcri;   // exercise iterator requirements
+
+    _RWSTD_UNUSED (ti);  _RWSTD_UNUSED (tci);
+    _RWSTD_UNUSED (tri); _RWSTD_UNUSED (tcri);
+
+    // special treatment
+    TEST_REFERENCE (typename Allocator::reference,       reference);
+    TEST_REFERENCE (typename Allocator::const_reference, const_reference);
+}
+
+/**************************************************************************/
+
+// verify that member functions are properly defined
+template <class Vector, class T, class Allocator>
+void test_signatures (Vector*, T*, Allocator)
+{
+// verify that a member function is accessible and has the appropriate
+// signature, including return type and exception specification
+#define MEMFUN(result, name, arg_list) do {              \
+        result (Vector::*pf) arg_list = &Vector::name;   \
+        _RWSTD_UNUSED (pf);                              \
+    } while (0)
+
+    MEMFUN (Vector&, operator=, (const Vector&));
+
+    // helpers to work around a SunPro 5.3 bug (see PR #25972)
+    typedef typename Vector::size_type  SizeType;
+    typedef typename Vector::value_type ValueType;
+    typedef typename Vector::iterator   Iterator;
+
+    // verify signatures of iterator accessors
+    MEMFUN (typename Vector::iterator,       begin, ());
+    MEMFUN (typename Vector::const_iterator, begin, () const);
+    MEMFUN (typename Vector::iterator,       end, ());
+    MEMFUN (typename Vector::const_iterator, end, () const);
+
+    // verify signatures of reverse iterator accessors
+    MEMFUN (typename Vector::reverse_iterator,       rbegin, ());
+    MEMFUN (typename Vector::const_reverse_iterator, rbegin, () const);
+    MEMFUN (typename Vector::reverse_iterator,       rend, ());
+    MEMFUN (typename Vector::const_reverse_iterator, rend, () const);
+
+    // verify signatures of capacity accessors
+    MEMFUN (SizeType, size, () const);
+    MEMFUN (SizeType, max_size, () const);
+    MEMFUN (void, resize, (SizeType, ValueType));
+    MEMFUN (SizeType, capacity, () const);
+    MEMFUN (bool, empty, () const);
+    MEMFUN (void, reserve, (SizeType));
+
+    // verify signature of the element access functions
+    MEMFUN (const T&, operator[], (SizeType) const);
+    MEMFUN (T&,       operator[], (SizeType));
+    MEMFUN (const T&, at,         (SizeType) const);
+    MEMFUN (T&,       at,         (SizeType));
+    MEMFUN (const T&, front, () const);
+    MEMFUN (T&,       front, ());
+    MEMFUN (const T&, back, () const);
+    MEMFUN (T&,       back, ());
+
+    // verify signatures of modifiers
+    MEMFUN (void, push_back, (const T&));
+    MEMFUN (void, pop_back, ());
+
+    MEMFUN (Iterator, insert, (Iterator, const T&));
+
+    MEMFUN (void, insert, (Iterator, SizeType, const T&));
+
+#if !defined (_RWSTD_NO_INLINE_MEMBER_TEMPLATES) \
+    && (!defined (_MSC_VER) || _MSC_VER >= 1300)
+    // member function template insert
+    MEMFUN (void, insert, (Iterator, InputIter<T>, InputIter<T>));
+#endif   // _RWSTD_NO_INLINE_MEMBER_TEMPLATES
+
+    MEMFUN (Iterator, erase, (Iterator));
+    MEMFUN (Iterator, erase, (Iterator, Iterator));
+
+    MEMFUN (void, swap, (Vector&));
+    MEMFUN (void, clear, ());
+
+#if !defined (_MSC_VER) || _MSC_VER > 1300
+
+#define FUN(result, name, arg_list) do {  \
+        result (*pf) arg_list = &name;    \
+        _RWSTD_UNUSED (pf);               \
+    } while (0)
+
+    // verify signatures of non-member functions
+    FUN (bool, std::operator==, (const Vector&, const Vector&));
+    FUN (bool, std::operator<,  (const Vector&, const Vector&));
+    FUN (bool, std::operator!=, (const Vector&, const Vector&));
+    FUN (bool, std::operator>,  (const Vector&, const Vector&));
+    FUN (bool, std::operator>=, (const Vector&, const Vector&));
+    FUN (bool, std::operator<=, (const Vector&, const Vector&));
+    FUN (void, std::swap,       (Vector&, Vector&));
+
+#else   // MSVC <= 7.0
+
+    // working around a bug in MSVC 7 and prior (see PR #26625)
+
+    if (0 /* compile only */) {
+
+        Vector *pv = 0;
+        const Vector *pcv = 0;
+
+        bool b;
+        b = std::operator== (*pcv, *pcv);
+        b = std::operator<  (*pcv, *pcv);
+        b = std::operator!= (*pcv, *pcv);
+        b = std::operator>  (*pcv, *pcv);
+        b = std::operator>= (*pcv, *pcv);
+        b = std::operator<= (*pcv, *pcv);
+        std::swap (*pv, *pv);
+    }
+
+#endif   // MSVC <= 7.0
+
+}
+
+/**************************************************************************/
+
+// exercise [lib.vector.cons] and vector<>::operator=()
+// focus on the correct construction and destruction of values
+void test_ctors ()
+{
+    typedef std::vector<X, std::allocator<X> > Vector;
+
+    if (1) {
+
+        rw_info (0, 0, 0,
+                 "std::vector<X>::vector(size_type, "
+                 "const_reference, const allocator_type&)");
+
+        rw_info (0, 0, 0, "std::vector<X>::vector(const vector&)");
+
+        // reset function call counters
+        X::reset_totals ();
+
+        // total number of objects of type X in existence
+        const std::size_t x_count = X::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); "
+                       "leaked %zu objects of value_type",
+                       X::count_ - x_count);
+
+            // reset function call counters
+            X::reset_totals ();
+
+            const X val;
+
+            // initialize a vector with `i' copies of `val'
+            const Vector v0 (i, val);
+            rw_assert (   i == v0.size ()
+                       && v0.begin ()  + i  == v0.end ()
+                       && v0.rbegin () + i  == v0.rend (),
+                       0, __LINE__,
+                       "vector<X>::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); "
+                       "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);
+
+            // create a copy
+            Vector v1 (v0);
+            rw_assert (   i == v1.size ()
+                       && v1.begin  () + i == v1.end ()
+                       && v1.rbegin () + i == v1.rend (),
+                       0, __LINE__,
+                       "vector<X>::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),
+                       0, __LINE__,
+                       "vector<X>::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);
+
+            // exercise vector<>operator=(const vector&)
+            Vector v2 (i, val);
+
+            for (Vector::size_type j = 0; j != rw_opt_nloops; ++j) {
+
+                Vector v3 (j, val);
+
+                // 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);
+
+                rw_assert (v3 == v2, 0, __LINE__,
+                           "%zu. vector<X>::operator=(const vector&)", j);
+            }
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+            // exercise vector exception safety
+
+            bool thrown = false;
+
+            // create a suitably aligned buffer in which to construct
+            // the vector object
+            union {
+                void *pad;
+                char buf [sizeof (Vector)];
+            } buf = { 0 };
+
+            std::size_t x_count_save = X::count_;
+
+            try {
+                // have X copy ctor throw an exception during
+                // the copying of the last value
+                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + i;
+
+                // create a vector object, throw an exception
+                // expect vector ctor to destroy any values
+                // constructed prior to throwing the exception
+                // and to free all already allocated memory
+
+                // use placement new to prevent vector destruction
+                // at scope exit (the object should be destroyed
+                // during stack unwinding instead)
+                Vector *p = new (&buf.buf) Vector (i, val);
+
+                // destroy explicitly if ctor doesn't propagate exception
+
+#if !defined (__HP_aCC) || _RWSTD_HP_aCC_MINOR > 3800
+
+                p->~Vector ();
+#else
+                // work around aCC bug (see PR #25356)
+                p->~vector ();
+
+#endif   // HP aCC
+
+            }
+            catch (...) {
+                thrown = true;
+            }
+
+            // no exception thrown if (i == 0), no elements constructed
+            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) "
+                       "leaked %zu value(s) of %zu after an exception",
+                       X::count_ - x_count_save, i);
+
+            // exercise vector<>::vector(const vector&)
+            thrown       = false;
+            x_count_save = X::count_;
+
+            try {
+                // have X copy ctor throw an exception during
+                // the copying of the last value
+                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + i;
+
+                // use placement new to prevent vector destruction
+                // at scope exit (the object should be destroyed
+                // during stack unwinding instead)
+                Vector *p = new (&buf) Vector (v1);
+
+                // destroy explicitly if ctor doesn't propagate exception
+
+#if !defined (__HP_aCC) || _RWSTD_HP_aCC_MINOR > 3800
+
+                p->~Vector ();
+#else
+                // work around aCC bug (see PR #25356)
+                p->~vector ();
+
+#endif   // HP aCC
+
+            }
+            catch (...) {
+                // vector should have been destroyed
+                thrown = true;
+            }
+
+            // no exception thrown if (i == 0), no elements constructed
+            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 "
+                       "%zu value(s) of %zu after an exception",
+                       X::count_ - x_count_save, i);
+
+
+            // disable exceptions
+            X::copy_ctor_throw_count_ = std::size_t (-1);
+
+            // remember v1's size and capacity
+            const Vector::size_type v1_size = v1.size ();
+            const Vector::size_type v1_cap  = v1.capacity ();
+
+            // create and initialize vector with some values
+            // make sure v3's capacity is greater than that of v1
+            // (otherwise the assignment isn't exception safe since
+            // it simply overwrites existing values for efficiency)
+            const Vector v3 (v1_cap * 2, val);
+
+            // exrecise vector<>::operator=(const vector&)
+            thrown       = false;
+            x_count_save = X::count_;
+
+            try {
+                // have X copy ctor throw an exception during
+                // the copying of the last value
+                X::copy_ctor_throw_count_ = X::n_total_copy_ctor_ + v3.size ();
+
+                // assign over the existing elements, the last copy ctor or
+                // operator=() throws, destroying all values assigned so far
+                v1 = v3;
+            }
+            catch (...) {
+                // original vector must remain unchanged
+                thrown = true;
+            }
+
+            // disable exceptions
+            X::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 "
+                       "%zu value(s) of %zu after an exception",
+                       X::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",
+                       i / 2, v3.size ());
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+            // vectors go out of scope, must destroy all elements
+        }
+    }
+}
+
+// exercise [lib.vector.cons]
+template <class Vector, class T, class Alloc>
+void test_ctors (Vector*, T*, Alloc alloc)
+{
+    if (1) {
+
+        rw_info (0, 0, 0, "std::vector<X>::vector(const allocator_type&)");
+
+        // verify default ctor arguments
+        Vector v0;
+        Vector v1 (alloc);
+
+        rw_assert (   0 == v0.size ()
+                   && v0.empty () && v0.begin () == v0.end ()
+                   && v0.rbegin () == v0.rend (), 0, __LINE__,
+                      ("vector<X>::vector()"));
+
+        rw_assert (   0 == v1.size ()
+                   && v1.empty () && v1.begin () == v1.end ()
+                   && v1.rbegin () == v1.rend (), 0, __LINE__,
+                      "vector<X>::vector()");
+    }
+
+    if (1) {
+
+        rw_info (0, 0, 0,
+                 "std::vector<X>::vector(size_type, "
+                 "const_reference, const allocator_type&)");
+
+        for (typename Vector::size_type i = 0; i != rw_opt_nloops; ++i) {
+
+            const T val = i;
+
+            Vector v0 (i, val);
+            Vector v1 (i, val, alloc);
+
+            rw_assert (   i == v0.size ()
+                       && v0.begin  () + i == v0.end ()
+                       && v0.rbegin () + i == v0.rend (),
+                          0, __LINE__,
+                          "vector<X>::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&)");
+
+            bool success = true;
+            for (typename Vector::size_type j = 0; j != i; ++j) {
+                if (!(success = v0 [j] == val))
+                    break;
+                if (!(success = v1 [j] == val))
+                    break;
+            }
+
+            rw_assert (success, 0, __LINE__,
+                       "vector<X>::vector(size_type, const_reference); "
+                       "all elements initialized");
+        }
+    }
+
+#if !defined (_RWSTD_NO_INLINE_MEMBER_TEMPLATES) \
+    && (!defined (_MSC_VER) || _MSC_VER >= 1300)
+
+    if (1) {
+
+        rw_info (0, 0, 0,
+                 "template <class InputIterator> std::vector<X>::vector "
+                 "(InputIterator, InputIterator)");
+
+        bool success = true;
+
+        // allocate nloops elements, do not initialize
+        typename Vector::value_type *vals = alloc.allocate (rw_opt_nloops);
+
+        for (typename Vector::size_type i = 0; i != rw_opt_nloops; ++i) {
+
+            // construct an element at then end of array
+            alloc.construct (vals + i, i);
+
+            // verify ctor with a strict InputIterator
+            InputIter<T> first (vals,     vals,     vals + i);
+            InputIter<T> last  (vals + i, vals + i, vals + i);
+
+            const Vector v0 (first, last);
+
+            // reset iterators since they are single-pass and their
+            // copies have been passed through by the ctor above
+            first = InputIter<T>(vals,     vals,     vals + i);
+            last  = InputIter<T>(vals + i, vals + i, vals + i);
+
+            const Vector v1 (first, last, alloc);
+
+            if (   i != v0.size ()
+                || (!(i && !v0.empty () || !i && v0.empty ()))
+                || (i != v1.size ())
+                || (!(i && !v1.empty () || !i && v1.empty ())))
+                success = false;
+
+            // verify size() and empty()
+            rw_assert (i == v0.size (), 0, __LINE__,
+                       "size () == %zu, got %zu", i, v0.size ());
+
+            rw_assert (i && !v0.empty () || !i && v0.empty (),
+                       0, __LINE__, "size () == %zu, empty () == %d",
+                       v0.size (), v0.empty ());
+
+            rw_assert (i == v1.size (), 0, __LINE__,
+                       "size () == %zu, got %zu", i, v1.size ());
+
+            rw_assert (i && !v1.empty () || !i && v1.empty (),
+                       0, __LINE__, "size () == %zu, empty () == %d",
+                       v1.size (), v1.empty ());
+        }
+
+        rw_assert (success, 0, __LINE__,
+                   "template <class InputIterator> "
+                   "std::vector<X>::vector(InputIterator, InputIterator)");
+
+        // destroy and deallocate...
+        for (typename Vector::size_type j = 0; j != rw_opt_nloops; ++j)
+            alloc.destroy (vals + j);
+
+        alloc.deallocate (vals, rw_opt_nloops);
+    }
+
+#endif   // _RWSTD_NO_INLINE_MEMBER_TEMPLATES
+
+}
+
+/**************************************************************************/
+
+static int
+run_test (int /* argc */, char** /* argv */)
+{
+    static int int_noted   = 0;
+    static int short_noted = 0;
+    static int types_noted = 0;
+    static int sign_noted  = 0;
+    static int ctors_noted = 0;
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+    try {
+        // throw an exception to initialize the lib (allocates
+        // memory that's never deallocated; shows up as leaks)
+        _RW::__rw_throw (_RWSTD_ERROR_LOGIC_ERROR, "", "");
+    }
+    catch (...) {
+    }
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+
+// for convenience (in case default template arguments are disabled)
+#define VECTOR(T)  std::vector<T, std::allocator<T> >
+
+#define TEST(what, T)                                                     \
+    do {                                                                  \
+        /* establish a checkpoint for memory leaks */                     \
+        rwt_check_leaks (0, 0);                                           \
+        test_ ##what ((VECTOR (T)*)0, (T*)0, std::allocator<T>());        \
+        /* verify that no memory leaked */                                \
+        std::size_t nbytes;                                               \
+        const std::size_t nblocks = rwt_check_leaks (&nbytes, 0);         \
+        rw_assert (!nblocks && !nbytes, 0, __LINE__,                      \
+                   #what " test leaked %lu bytes in %lu blocks",          \
+                   nbytes, nblocks);                                      \
+    } while (0)
+
+    if (rw_opt_no_int_spec) {
+        rw_note (int_noted++, 0, __LINE__,
+                 "int specializations test disabled.");
+    }
+    else {
+        // exercise vector and its default template argument
+        if (rw_opt_no_types) {
+            rw_note (types_noted++, 0, __LINE__, "Types test disabled.");
+        }
+        else {
+            TEST (types, int);
+        }
+
+        if (rw_opt_no_signatures) {
+            rw_note (sign_noted++, 0, __LINE__, "Signatures test disabled.");
+        }
+        else {
+            TEST (signatures, int);
+        }
+
+        if (rw_opt_no_ctors) {
+            rw_note (ctors_noted++, 0, __LINE__, "Ctors test disabled.");
+        }
+        else {
+            TEST (ctors, int);
+        }
+    }
+
+    // exercise vector with a template argument other than the default
+#undef  VECTOR
+#define VECTOR(T, A) std::vector<T, A<T> >
+
+#undef  TEST
+#define TEST(what,T,A) test_ ##what ((VECTOR (T, A)*)0, (T*)0, A<T>())
+
+    if (rw_opt_no_short_spec) {
+        rw_note (short_noted++, 0, __LINE__,
+                 "short specializations test disabled.");
+    }
+    else {
+        if (rw_opt_no_types) {
+            rw_note (types_noted++, 0, __LINE__, "Types test disabled.");
+        }
+        else {
+            TEST (types, short, std::allocator);
+        }
+
+        if (rw_opt_no_signatures) {
+            rw_note (sign_noted++, 0, __LINE__, "Signatures test disabled.");
+        }
+        else {
+            TEST (signatures, short, std::allocator);
+        }
+
+        if (rw_opt_no_ctors) {
+            rw_note (ctors_noted++, 0, __LINE__, "Ctors test disabled.");
+        }
+        else {
+            TEST (ctors, short, std::allocator);
+        }
+    }
+
+    if (rw_opt_no_ctors) {
+        rw_note (ctors_noted++, 0, __LINE__, "Ctors test disabled.");
+    }
+    else {
+        test_ctors ();
+    }
+
+    return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char** argv)
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.vector.cons",
+                    0 /* no comment */,
+                    run_test,
+                    "|-nloops#1 "
+                    "|-no-int_specializations# "
+                    "|-no-short_specializations# "
+                    "|-no-types# "
+                    "|-no-signatures# "
+                    "|-no-ctors#",
+                    &rw_opt_nloops,
+                    &rw_opt_no_int_spec,
+                    &rw_opt_no_short_spec,
+                    &rw_opt_no_types,
+                    &rw_opt_no_signatures,
+                    &rw_opt_no_ctors);
+}

Propchange: incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/containers/23.vector.cons.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message