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 <[EMAIL PROTECTED]>
* 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
