Author: faridz
Date: Fri Feb 23 09:04:11 2007
New Revision: 511019
URL: http://svn.apache.org/viewvc?view=rev&rev=511019
Log:
2007-02-23 Farid Zaripov <[EMAIL PROTECTED]>
ChangeLog:
* 23.list.h: New file with definitions of helpers used in
clause 23.list tests.
* 23.containers.cpp: #included 23.list.h; removed definition
of the temporary struct ListIds; _rw_list_sigcat filled by code.
Added:
incubator/stdcxx/trunk/tests/include/23.list.h (with props)
Modified:
incubator/stdcxx/trunk/tests/src/23.containers.cpp
Added: incubator/stdcxx/trunk/tests/include/23.list.h
URL:
http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/include/23.list.h?view=auto&rev=511019
==============================================================================
--- incubator/stdcxx/trunk/tests/include/23.list.h (added)
+++ incubator/stdcxx/trunk/tests/include/23.list.h Fri Feb 23 09:04:11 2007
@@ -0,0 +1,285 @@
+/************************************************************************
+*
+* 23.list.h - definitions of helpers used in clause 23.list tests
+*
+* $Id: 23.list.h
+*
+***************************************************************************
+*
+* 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.
+*
+**************************************************************************/
+
+#ifndef RW_23_LIST_H_INCLUDED
+#define RW_23_LIST_H_INCLUDED
+
+#include <23.containers.h>
+
+/**************************************************************************/
+
+// defines enumerations identifying list template arguments,
+// sets of overloaded functions, member types used in the declarations
+// of their signatures, and specific overloads of such member functions
+struct ListIds : ContainerIds
+{
+// define the helper macros
+#include <rw_sigdefs.h>
+
+ // unique identifiers for all overloads of each member function
+ // 6 bits for FuncId
+ // 6 * 4 bits for ArgId (at most 6 arguments including this)
+ // 1 bit for membership
+ enum OverloadId {
+ //////////////////////////////////////////////////////////////
+ // list ()
+ MEMBER_0 (ctor, cont),
+ // list (const allocator_type&)
+ MEMBER_1 (ctor, cont, alloc),
+ // list (const list&)
+ MEMBER_1 (ctor, cont, ccont),
+ // list (size_type)
+ MEMBER_1 (ctor, cont, size),
+ // list (size_type, const value_type&)
+ MEMBER_2 (ctor, cont, size, cref),
+ // list (size_type, const value_type&, const allocator_type&)
+ MEMBER_3 (ctor, cont, size, cref, alloc),
+ // list (InputIterator, InputIterator)
+ MEMBER_1 (ctor, cont, range),
+ // list (InputIterator, InputIterator, const allocator&)
+ MEMBER_2 (ctor, cont, range, alloc),
+
+ //////////////////////////////////////////////////////////////
+ // operator= (const list&)
+ MEMBER_1 (op_set, cont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // assign (size_type, const value_type&)
+ MEMBER_2 (assign, cont, size, cref),
+ // assign (InputIterator, InputIterator)
+ MEMBER_1 (assign, cont, range),
+
+ //////////////////////////////////////////////////////////////
+ // get_allocator () const
+ MEMBER_0 (get_allocator, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // begin ()
+ MEMBER_0 (begin, cont),
+ // begin () const
+ MEMBER_0 (begin_const, ccont),
+ // end ()
+ MEMBER_0 (end, cont),
+ // end () const
+ MEMBER_0 (end_const, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // rbegin ()
+ MEMBER_0 (rbegin, cont),
+ // rbegin () const
+ MEMBER_0 (rbegin_const, ccont),
+ // rend ()
+ MEMBER_0 (rend, cont),
+ // rend () const
+ MEMBER_0 (rend_const, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // empty ()
+ MEMBER_0 (empty, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // size ()
+ MEMBER_0 (size, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // max_size ()
+ MEMBER_0 (max_size, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // resize (size_type)
+ MEMBER_1 (resize, cont, size),
+ // resize (size_type, value_type)
+ MEMBER_2 (resize, cont, size, val),
+
+ //////////////////////////////////////////////////////////////
+ // front ()
+ MEMBER_0 (front, cont),
+ // front () const
+ MEMBER_0 (front_const, ccont),
+ // back ()
+ MEMBER_0 (back, cont),
+ // back () const
+ MEMBER_0 (back_const, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // push_front (const value_type&)
+ MEMBER_1 (push_front, cont, cref),
+ // pop_front ()
+ MEMBER_0 (pop_front, cont),
+ // push_back (const value_type&)
+ MEMBER_1 (push_back, cont, cref),
+ // pop_back ()
+ MEMBER_0 (pop_back, cont),
+
+ //////////////////////////////////////////////////////////////
+ // insert (iterator, const value_type&)
+ MEMBER_2 (insert, cont, iter, cref),
+ // insert (iterator, size_type, const value_type&)
+ MEMBER_3 (insert, cont, iter, size, cref),
+ // insert (iterator, InputIterator, InputIterator)
+ MEMBER_2 (insert, cont, iter, range),
+
+ //////////////////////////////////////////////////////////////
+ // erase (iterator)
+ MEMBER_1 (erase, cont, iter),
+ // erase (iterator, iterator)
+ MEMBER_2 (erase, cont, iter, iter),
+
+ //////////////////////////////////////////////////////////////
+ // swap (list&)
+ MEMBER_1 (swap, cont, cont),
+ // swap (list&, list&)
+ NON_MEMBER_2 (swap, cont, cont),
+
+ //////////////////////////////////////////////////////////////
+ // clear ()
+ MEMBER_0 (clear, cont),
+
+ //////////////////////////////////////////////////////////////
+ // splice (iterator, list&)
+ MEMBER_2 (splice, cont, iter, cont),
+ // splice (iterator, list&, iterator)
+ MEMBER_3 (splice, cont, iter, cont, iter),
+ // splice (iterator, list&, iterator, iterator)
+ MEMBER_4 (splice, cont, iter, cont, iter, iter),
+
+ //////////////////////////////////////////////////////////////
+ // remove (const value_type&)
+ MEMBER_1 (remove, cont, cref),
+ // remove_if (Predicate)
+ MEMBER_1 (remove_if, cont, pred),
+
+ //////////////////////////////////////////////////////////////
+ // unique (BinaryPredicate)
+ MEMBER_1 (unique, cont, bpred),
+
+ //////////////////////////////////////////////////////////////
+ // merge (list&)
+ MEMBER_1 (merge, cont, cont),
+ // merge (list&, Compare)
+ MEMBER_2 (merge, cont, cont, comp),
+
+ //////////////////////////////////////////////////////////////
+ // sort ()
+ MEMBER_0 (sort, cont),
+ // sort (Compare)
+ MEMBER_1 (sort, cont, comp),
+
+ //////////////////////////////////////////////////////////////
+ // reverse ()
+ MEMBER_0 (reverse, cont),
+
+ //////////////////////////////////////////////////////////////
+ // operator== (const list&, const list&)
+ NON_MEMBER_2 (op_equal, ccont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // operator< (const list&, const list&)
+ NON_MEMBER_2 (op_less, ccont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // operator!= (const list&, const list&)
+ NON_MEMBER_2 (op_not_equal, ccont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // operator> (const list&, const list&)
+ NON_MEMBER_2 (op_greater, ccont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // operator>= (const list&, const list&)
+ NON_MEMBER_2 (op_greater_equal, ccont, ccont),
+
+ //////////////////////////////////////////////////////////////
+ // operator<= (const list&, const list&)
+ NON_MEMBER_2 (op_less_equal, ccont, ccont)
+ };
+
+// clean up helper macros used above
+#include <rw_sigdefs.h>
+
+};
+
+/**************************************************************************/
+
+template <class InputIter1, class InputIter2>
+static inline bool
+_rw_equal (InputIter1 first1, InputIter1 last1, InputIter2 first2)
+{
+ for (; first1 != last1 && *first1 == *first2; ++first1, ++first2) ;
+
+ return first1 == last1;
+}
+
+// encapsulates the state of a list object
+// used in exception safety tests to determine changes to the state
+// after a modifying operation throws an exception
+template <class List>
+struct ListState
+{
+ typedef typename List::const_iterator ListCIter;
+ typedef typename List::const_pointer ListCPtr;
+
+ _RWSTD_SIZE_T size_;
+ ListCIter* iters_;
+ ListCPtr* ptrs_;
+
+ ListState (List const & lst) : size_ (lst.size ()), iters_ (0), ptrs_ (0)
+ {
+ iters_ = new ListCIter [size_];
+ ptrs_ = new ListCPtr [size_];
+
+ _RWSTD_SIZE_T index = 0;
+ for (ListCIter it = lst.begin (), end = lst.end ();
+ it != end; ++it, ++index) {
+
+ iters_ [index] = it;
+ ptrs_ [index] = &*it;
+ }
+ }
+
+ ~ListState ()
+ {
+ delete [] iters_;
+ delete [] ptrs_;
+ }
+
+ // invokes rw_assert() to verify that two states are the same
+ void assert_equal (const ListState& state, int line,
+ int case_line, const char* when) const
+ {
+ const int equal = size_ == state.size_
+ && _rw_equal (iters_, iters_ + size_, state.iters_)
+ && _rw_equal (ptrs_, ptrs_ + size_, state.ptrs_);
+
+ rw_assert (equal, 0, case_line,
+ "line %d: %{$FUNCALL}: object state unexpectedly changed "
+ "after %s", line, when);
+ }
+};
+
+/**************************************************************************/
+
+#endif // RW_23_LIST_H_INCLUDED
Propchange: incubator/stdcxx/trunk/tests/include/23.list.h
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/include/23.list.h
------------------------------------------------------------------------------
svn:keywords = Id
Modified: incubator/stdcxx/trunk/tests/src/23.containers.cpp
URL:
http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/src/23.containers.cpp?view=diff&rev=511019&r1=511018&r2=511019
==============================================================================
--- incubator/stdcxx/trunk/tests/src/23.containers.cpp (original)
+++ incubator/stdcxx/trunk/tests/src/23.containers.cpp Fri Feb 23 09:04:11 2007
@@ -30,6 +30,7 @@
#include <memory> // for allocator
#include <23.containers.h>
+#include <23.list.h>
#include <cmdopt.h> // for rw_enabled()
#include <rw_allocator.h> // for UserAlloc
@@ -344,19 +345,174 @@
/**************************************************************************/
-// temporary, shuld be defined in 23.list.h
-struct ListIds : ContainerIds
-{
- enum OverloadId {};
-};
-
static void
_rw_list_sigcat (char** pbuf, size_t * pbufsize, ListIds::OverloadId which,
bool self, const char* str, size_t str_len,
const char* arg, size_t arg_len,
const ContainerTestCase &tcase)
{
- // temporary empty
+ // compute the end offsets for convenience
+ const size_t range1_end = tcase.off + tcase.size;
+ const size_t range2_end = tcase.off2 + tcase.size2;
+
+ // determine whether the function takes an allocator_type argument
+ const bool use_alloc = 0 < _rw_argno (which, ContainerIds::arg_alloc);
+
+ // format and append cont function arguments abbreviating complex
+ // expressions as much as possible to make them easy to understand
+ switch (which) {
+ case ListIds::ctor_ccont:
+ case ListIds::op_set_ccont:
+ case ListIds::swap_cont:
+ case ListIds::merge_cont:
+ // format self-referential cont argument as *this
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%{?}*this%{:}%{$Container}(%{#*s})%{;}"
+ "%{?}, const allocator_type&%{;})",
+ self, int (arg_len), arg, use_alloc);
+ break;
+
+ case ListIds::assign_size_cref:
+ case ListIds::ctor_size_cref:
+ case ListIds::ctor_size_cref_alloc:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%zu, %{#c}%{?}, const allocator_type&%{;})",
+ tcase.size, tcase.val, use_alloc);
+ break;
+
+ case ListIds::assign_range:
+ case ListIds::ctor_range:
+ case ListIds::ctor_range_alloc:
+ rw_asnprintf (pbuf, pbufsize, "%{+}<%{$Iterator:-Iterator}>("
+ "%{?}begin()%{:}%{$Iterator:-Iterator}(%{#*s})%{;}"
+ "%{?} + %zu%{;}, "
+ "%{?}begin()%{:}%{$Iterator:-Iterator}(...)%{;}"
+ "%{?} + %zu%{;}"
+ "%{?}, const allocator_type&%{;})",
+ self, int (arg_len), arg,
+ 0 != tcase.off2, tcase.off2,
+ self, 0 != range2_end, range2_end, use_alloc);
+ break;
+
+ case ListIds::insert_iter_cref:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (begin()%{?} + %zu%{;}, %{#c})",
+ 0 != tcase.off, tcase.off, tcase.val);
+ break;
+
+ case ListIds::insert_iter_size_cref:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (begin()%{?} + %zu%{;}, %zu, %{#c})",
+ 0 != tcase.off, tcase.off, tcase.size, tcase.val);
+ break;
+
+ case ListIds::insert_iter_range:
+ rw_asnprintf (pbuf, pbufsize, "%{+}<%{$Iterator:-Iterator}>"
+ "(begin()%{?} + %zu%{;}, "
+ "%{?}begin()%{:}%{$Iterator:-Iterator}(%{#*s})%{;}"
+ "%{?} + %zu%{;}, "
+ "%{?}begin()%{:}%{$Iterator:-Iterator}(...)%{;}"
+ "%{?} + %zu%{;})",
+ 0 != tcase.off, tcase.off,
+ self, int (arg_len), arg,
+ 0 != tcase.off2, tcase.off2,
+ self, 0 != range2_end, range2_end);
+ break;
+
+ case ListIds::push_front_cref:
+ case ListIds::push_back_cref:
+ case ListIds::remove_cref:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%{#c})", tcase.val);
+ break;
+
+ case ListIds::ctor_void:
+ case ListIds::get_allocator_void:
+ case ListIds::begin_void:
+ case ListIds::end_void:
+ case ListIds::rbegin_void:
+ case ListIds::rend_void:
+ case ListIds::empty_void:
+ case ListIds::size_void:
+ case ListIds::max_size_void:
+ case ListIds::front_void:
+ case ListIds::back_void:
+ case ListIds::pop_front_void:
+ case ListIds::pop_back_void:
+ case ListIds::clear_void:
+ case ListIds::sort_void:
+ case ListIds::reverse_void:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} ()");
+ break;
+
+ case ListIds::begin_const_void:
+ case ListIds::end_const_void:
+ case ListIds::rbegin_const_void:
+ case ListIds::rend_const_void:
+ case ListIds::front_const_void:
+ case ListIds::back_const_void:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} () const");
+ break;
+
+ case ListIds::ctor_alloc:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (const allocator_type&)");
+ break;
+
+ case ListIds::erase_iter:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (begin()%{?} + %zu%{;})",
+ 0 != tcase.off, tcase.off);
+ break;
+
+ case ListIds::erase_iter_iter:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (begin()%{?} + %zu%{;}, begin()%{?} + %zu%{;})",
+ 0 != tcase.off, tcase.off,
+ 0 != range1_end, range1_end);
+ break;
+
+ case ListIds::op_equal_ccont_ccont:
+ case ListIds::op_less_ccont_ccont:
+ case ListIds::op_not_equal_ccont_ccont:
+ case ListIds::op_greater_ccont_ccont:
+ case ListIds::op_greater_equal_ccont_ccont:
+ case ListIds::op_less_equal_ccont_ccont:
+ // format zero cont argument without size as arg
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%{?}arg2%{:}%{$CLASS}(%{#*s})%{;}, "
+ "%{?}arg1%{:}%{$CLASS}(%{#*s})%{;})",
+ 0 == str, int (str_len), str, self, int (arg_len), arg);
+ break;
+
+ case ListIds::ctor_size:
+ case ListIds::resize_size:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%zu)", tcase.size);
+ break;
+
+ case ListIds::resize_size_val:
+ rw_asnprintf (pbuf, pbufsize,
+ "%{+} (%zu, %{#c})", tcase.size, tcase.val);
+ break;
+
+ case ListIds::swap_cont_cont:
+ case ListIds::splice_iter_cont:
+ case ListIds::splice_iter_cont_iter:
+ case ListIds::splice_iter_cont_iter_iter:
+ case ListIds::remove_if_pred:
+ case ListIds::unique_bpred:
+ case ListIds::merge_cont_comp:
+ case ListIds::sort_comp:
+ rw_asnprintf (pbuf, pbufsize,
+ "not yet defined");
+ break;
+
+ default:
+ RW_ASSERT (!"test logic error: unknown list overload");
+ }
}
/**************************************************************************/
