Modified: incubator/stdcxx/trunk/tests/strings/21.string.replace.cpp URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/strings/21.string.replace.cpp?rev=396375&r1=396374&r2=396375&view=diff ============================================================================== --- incubator/stdcxx/trunk/tests/strings/21.string.replace.cpp (original) +++ incubator/stdcxx/trunk/tests/strings/21.string.replace.cpp Sun Apr 23 18:58:16 2006 @@ -44,37 +44,12 @@ # include <rw_new.h> #endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE -#define ReplaceOverload StringMembers::MemberFunction +#define ReplaceOverload StringMembers::OverloadId #define Replace(which) StringMembers::replace_ ## which -#define Disabled(which) StringMembers::opt_memfun_disabled [which] typedef StringMembers::TestCase TestCase; typedef StringMembers::Test Test; - -/**************************************************************************/ - -const char method_name[] = "replace"; - -/**************************************************************************/ - -struct MemFun -{ - typedef StringMembers::charT charT; - typedef StringMembers::Traits Traits; - - MemFun (charT cid, const char *cname, - Traits tid, const char *tname) - : cid_ (cid), tid_ (tid), - cname_ (cname), tname_ (tname), aname_ ("allocator"), - fname_ ("replace") { /* empty */ } - - charT cid_; // character type id (char or wchar_t) - Traits tid_; // traits type id (default or user-defined) - const char *cname_; // character type name - const char *tname_; // traits name - const char *aname_; // allocator name - const char *fname_; // function name -}; +typedef StringMembers::Function MemFun; /**************************************************************************/ @@ -93,14 +68,16 @@ /**************************************************************************/ // used to exercise -// replace (size_type pos1, size_type n1, const charT* s) +// replace (size_type, size_type, const value_type*) static const TestCase -off_size_ptr_test_cases [] = { +size_size_ptr_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, res, bthrow) \ - { Replace (off_size_ptr), __LINE__, off, size, -1, -1, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, res, bthrow) { \ + __LINE__, off, size, -1, -1, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -184,14 +161,16 @@ /**************************************************************************/ // used to exercise -// replace (Iterator i1, Iterator i2, const charT* s) +// replace (iterator, iterator, const value_type*) static const TestCase -ptr_test_cases [] = { +iter_iter_ptr_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, res, bthrow) \ - { Replace (ptr), __LINE__, off, size, -1, -1, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, res, bthrow) { \ + __LINE__, off, size, -1, -1, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -275,14 +254,16 @@ /**************************************************************************/ // used to exercise -// replace (size_type pos1, size_type n1, basic_string& s) +// replace (size_type, size_type, const basic_string&) static const TestCase -off_size_str_test_cases [] = { +size_size_str_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, res, bthrow) \ - { Replace (off_size_str), __LINE__, off, size, -1, -1, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, res, bthrow) { \ + __LINE__, off, size, -1, -1, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -372,14 +353,16 @@ /**************************************************************************/ // used to exercise -// replace (Iterator i1, Iterator i2, basic_string& s) +// replace (iterator, iterator, const basic_string&) static const TestCase -str_test_cases [] = { +iter_iter_str_test_cases [] = { #undef TEST -#define TEST(s, off, size, arg, res, bthrow) \ - { Replace (str), __LINE__, off, size, -1, -1, -1, \ - s, sizeof s - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(s, off, size, arg, res, bthrow) { \ + __LINE__, off, size, -1, -1, -1, \ + s, sizeof s - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -469,14 +452,16 @@ /**************************************************************************/ // used to exercise -// replace (size_type pos1, size_type n1, const charT* s, size_type n2) +// replace (size_type, size_type, const value_type*, size_type) static const TestCase -off_size_ptr_size_test_cases [] = { +size_size_ptr_size_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, count, res, bthrow) \ - { Replace (off_size_ptr_size), __LINE__, off, size, -1, count, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, count, res, bthrow) { \ + __LINE__, off, size, -1, count, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -561,14 +546,16 @@ /**************************************************************************/ // used to exercise -// replace (Iterator i1, Iterator i2, const charT* s, size_type n2) +// replace (iterator, iterator, const value_type*, size_type) static const TestCase -ptr_size_test_cases [] = { +iter_iter_ptr_size_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, count, res, bthrow) \ - { Replace (ptr_size), __LINE__, off, size, -1, count, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, count, res, bthrow) { \ + __LINE__, off, size, -1, count, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -652,15 +639,16 @@ /**************************************************************************/ // used to exercise -// replace (size_type pos1, size_type n1, basic_string& s, -// size_type pos2, size_type n2) +// replace (size_type, size_type, const basic_string&, size_type, size_type) static const TestCase -off_size_str_off_size_test_cases [] = { +size_size_str_size_size_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, off2, size2, res, bthrow) \ - { Replace (off_size_str_off_size), __LINE__, off, size, off2, size2, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, off2, size2, res, bthrow) { \ + __LINE__, off, size, off2, size2, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos argument @@ -769,14 +757,16 @@ /**************************************************************************/ // used to exercise -// replace (iterator i1, Iterator i2, InputIterator j1, InputIterator j2) +// replace (iterator, Iterator, InputIterator, InputIterator) static const TestCase -range_test_cases [] = { +iter_iter_range_test_cases [] = { #undef TEST -#define TEST(str, off, size, arg, off2, size2, res, bthrow) \ - { Replace (range), __LINE__, off, size, off2, size2, -1, \ - str, sizeof str - 1, arg, sizeof arg - 1, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, arg, off2, size2, res, bthrow) { \ + __LINE__, off, size, off2, size2, -1, \ + str, sizeof str - 1, \ + arg, sizeof arg - 1, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos argument @@ -884,14 +874,15 @@ /**************************************************************************/ // used to exercise -// replace (size_type pos1, size_type n1, charT c, size_type n2) +// replace (size_type, size_type, value_type, size_type) static const TestCase -off_size_size_val_test_cases [] = { +size_size_size_val_test_cases [] = { #undef TEST -#define TEST(str, off, size, count, val, res, bthrow) \ - { Replace (off_size_size_val), __LINE__, off, size, -1, count, val, \ - str, sizeof str - 1, 0, 0, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, count, val, res, bthrow) { \ + __LINE__, off, size, -1, count, val, \ + str, sizeof str - 1, 0, 0, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -976,14 +967,16 @@ /**************************************************************************/ // used to exercise -// replace (iterator i1, Iterator i2, charT c, size_type n2) +// replace (iterator, iterator, size_type, value_type) static const TestCase -size_val_test_cases [] = { +iter_iter_size_val_test_cases [] = { #undef TEST -#define TEST(str, off, size, count, val, res, bthrow) \ - { Replace (size_val), __LINE__, off, size, -1, count, val, \ - str, sizeof str - 1, 0, 0, res, sizeof res - 1, bthrow } +#define TEST(str, off, size, count, val, res, bthrow) { \ + __LINE__, off, size, -1, count, val, \ + str, sizeof str - 1, \ + 0, 0, res, sizeof res - 1, bthrow \ + } // +------------------------------------------ controlled sequence // | +----------------------------- replace() pos1 argument @@ -1068,64 +1061,38 @@ /**************************************************************************/ -static const StringMembers::Test -tests [] = { - -#undef TEST -#define TEST(tag, sig) { \ - tag ## _test_cases, \ - sizeof tag ## _test_cases / sizeof *tag ## _test_cases, \ - "replace " sig \ - } - - TEST (off_size_ptr, "(size_type, size_type, const value_type*)"), - TEST (off_size_str, "(size_type, size_type, basic_string&)"), - TEST (off_size_ptr_size, - "(size_type, size_type, const value_type*, size_type)"), - TEST (off_size_str_off_size, - "size_type, size_type, basic_string&, size_type, size_type)"), - TEST (off_size_size_val, "(size_type, size_type, size_type, value_type)"), - TEST (ptr, "(iterator, iterator, const value_type*)"), - TEST (str, "(iterator, iterator, basic_string&)"), - TEST (ptr_size, "(iterator, iterator, const value_type*, size_type)"), - TEST (size_val, "(iterator, iterator, size_type, value_type)"), - TEST (range, "(iterator, iterator, InputIterator, InputIterator)") -}; - -/**************************************************************************/ - template <class charT, class Traits> void test_exceptions (charT, Traits*, - const TestCase &cs, - const char *funcall) + ReplaceOverload which, + const TestCase &tcase) { - typedef std::basic_string <charT, Traits, - std::allocator<charT> > TestString; - typedef typename TestString::iterator StringIter; - typedef typename TestString::const_iterator ConstStringIter; + typedef std::allocator<charT> Allocator; + typedef std::basic_string <charT, Traits, Allocator> TestString; + typedef typename TestString::iterator StringIter; + typedef typename TestString::const_iterator ConstStringIter; - const bool use_iters = (Replace (ptr) <= cs.which); + const bool use_iters = Replace (iter_iter_ptr) <= which; static charT wstr [LLEN]; static charT warg [LLEN]; - rw_widen (wstr, cs.str, cs.str_len); - rw_widen (warg, cs.arg, cs.arg_len); + rw_widen (wstr, tcase.str, tcase.str_len); + rw_widen (warg, tcase.arg, tcase.arg_len); - /* const */ TestString s_str (wstr, cs.str_len); - const TestString s_arg (warg, cs.arg_len); + /* const */ TestString s_str (wstr, tcase.str_len); + const TestString s_arg (warg, tcase.arg_len); - const int first = use_iters ? cs.off : cs.str_len + 1; - const int last = use_iters ? cs.off + cs.size : cs.str_len + 1; + const int first = use_iters ? tcase.off : tcase.str_len + 1; + const int last = use_iters ? tcase.off + tcase.size : tcase.str_len + 1; const StringIter it_first (std::size_t (first) >= s_str.size () ? s_str.end () : s_str.begin () + first); const StringIter it_last (std::size_t (last) >= s_str.size () ? s_str.end () : s_str.begin () + last); - const charT* const arg_ptr = cs.arg ? warg : s_str.c_str (); - const TestString& arg_str = cs.arg ? s_arg : s_str; - const charT arg_val = make_char (char (cs.val), (charT*)0); + const charT* const arg_ptr = tcase.arg ? warg : s_str.c_str (); + const TestString& arg_str = tcase.arg ? s_arg : s_str; + const charT arg_val = make_char (char (tcase.val), (charT*)0); std::size_t throw_after = 0; @@ -1153,34 +1120,35 @@ #endif // _RWSTD_NO_EXCEPTIONS _TRY { - if (Replace (off_size_ptr) == cs.which) - s_str.replace (cs.off, cs.size, arg_ptr); + if (Replace (size_size_ptr) == which) + s_str.replace (tcase.off, tcase.size, arg_ptr); - else if (Replace (off_size_str) == cs.which) - s_str.replace (cs.off, cs.size, arg_str); + else if (Replace (size_size_str) == which) + s_str.replace (tcase.off, tcase.size, arg_str); - else if (Replace (off_size_ptr_size) == cs.which) - s_str.replace (cs.off, cs.size, arg_ptr, cs.size2); + else if (Replace (size_size_ptr_size) == which) + s_str.replace (tcase.off, tcase.size, arg_ptr, tcase.size2); - else if (Replace (off_size_str_off_size) == cs.which) - s_str.replace (cs.off, cs.size, arg_str, cs.off2, cs.size2); + else if (Replace (size_size_str_size_size) == which) + s_str.replace (tcase.off, tcase.size, arg_str, + tcase.off2, tcase.size2); - else if (Replace (off_size_size_val) == cs.which) - s_str.replace (cs.off, cs.size, cs.size2, arg_val); + else if (Replace (size_size_size_val) == which) + s_str.replace (tcase.off, tcase.size, tcase.size2, arg_val); - else if (Replace (ptr) == cs.which) + else if (Replace (iter_iter_ptr) == which) s_str.replace (it_first, it_last, arg_ptr); - else if (Replace (str) == cs.which) + else if (Replace (iter_iter_str) == which) s_str.replace (it_first, it_last, arg_str); - else if (Replace (ptr_size) == cs.which) - s_str.replace (it_first, it_last, arg_ptr, cs.size2); + else if (Replace (iter_iter_ptr_size) == which) + s_str.replace (it_first, it_last, arg_ptr, tcase.size2); - else if (Replace (size_val) == cs.which) - s_str.replace (it_first, it_last, cs.size2, arg_val); + else if (Replace (iter_iter_size_val) == which) + s_str.replace (it_first, it_last, tcase.size2, arg_val); - else if (Replace (range) == cs.which) + else if (Replace (iter_iter_range) == which) s_str.replace (it_first, it_last, s_arg.begin(), s_arg.end()); break; @@ -1192,21 +1160,21 @@ // verify that an exception thrown during allocation // doesn't cause a change in the state of the vector - rw_assert (s_str.size () == size, 0, cs.line, - "line %d: %s: size unexpectedly changed " + rw_assert (s_str.size () == size, 0, tcase.line, + "line %d: %{$FUNCALL}: size unexpectedly changed " "from %zu to %zu after an exception", - __LINE__, funcall, size, s_str.size ()); + __LINE__, size, s_str.size ()); - rw_assert (s_str.capacity () == capacity, 0, cs.line, - "line %d: %s: capacity unexpectedly " + rw_assert (s_str.capacity () == capacity, 0, tcase.line, + "line %d: %{$FUNCALL}: capacity unexpectedly " "changed from %zu to %zu after an exception", - __LINE__, funcall, capacity, s_str.capacity ()); + __LINE__, capacity, s_str.capacity ()); - rw_assert (s_str.begin () == begin, 0, cs.line, - "line %d: %s: begin() unexpectedly " + rw_assert (s_str.begin () == begin, 0, tcase.line, + "line %d: %{$FUNCALL}: begin() unexpectedly " "changed from after an exception by %d", - __LINE__, funcall, s_str.begin () - begin); + __LINE__, s_str.begin () - begin); // increment to allow this call to operator new to succeed @@ -1225,9 +1193,9 @@ // at least one exception is thrown rw_assert ( *pst->throw_at_calls_ [0] == std::size_t (-1) || throw_after, - 0, cs.line, - "line %d: %s: failed to throw an expected exception", - __LINE__, funcall); + 0, tcase.line, + "line %d: %{$FUNCALL}: failed to throw an expected exception", + __LINE__); # endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE #else // if defined (_RWSTD_NO_EXCEPTIONS) @@ -1248,33 +1216,32 @@ /**************************************************************************/ template <class charT, class Traits, class Iterator> -void test_replace_range (const charT* wstr, - const charT* warg, +void test_replace_range (const charT* wstr, + const charT* warg, Traits*, const Iterator &it, - const TestCase &cs, - const char *funcall) + const TestCase &tcase) { typedef std::allocator<charT> Allocator; typedef std::basic_string <charT, Traits, Allocator> String; typedef typename String::iterator StringIter; const char* const itname = - cs.arg ? type_name (it, (charT*)0) : "basic_string::iterator"; + tcase.arg ? type_name (it, (charT*)0) : "basic_string::iterator"; - /* const */ String s_str (wstr, cs.str_len); - const String s_arg (warg, cs.arg_len); + /* const */ String s_str (wstr, tcase.str_len); + const String s_arg (warg, tcase.arg_len); - std::size_t off_last = cs.off + cs.size; - std::size_t off_first2 = cs.off2; - std::size_t off_last2 = cs.off2 + cs.size2; + std::size_t off_last = tcase.off + tcase.size; + std::size_t off_first2 = tcase.off2; + std::size_t off_last2 = tcase.off2 + tcase.size2; - const StringIter it_first (std::size_t (cs.off) >= s_str.size () ? - s_str.end () : s_str.begin () + cs.off); + const StringIter it_first (std::size_t (tcase.off) >= s_str.size () ? + s_str.end () : s_str.begin () + tcase.off); const StringIter it_last (std::size_t (off_last) >= s_str.size () ? s_str.end () : s_str.begin () + off_last); - if (cs.arg) { + if (tcase.arg) { off_first2 = off_first2 > s_arg.size () ? s_arg.size () : off_first2; off_last2 = off_last2 > s_arg.size () ? s_arg.size () : off_last2; @@ -1282,25 +1249,26 @@ const charT* const warg_end = warg + off_last2; const Iterator first (warg_beg, warg_beg, warg_end); - const Iterator last (warg_end, warg + cs.off2, warg_end); + const Iterator last (warg_end, warg + tcase.off2, warg_end); s_str.replace (it_first, it_last, first, last); } else { - const StringIter first (std::size_t (cs.off2) >= s_str.size () ? - s_str.end () : s_str.begin () + cs.size2); + const StringIter first (std::size_t (tcase.off2) >= s_str.size () ? + s_str.end () : s_str.begin () + tcase.size2); const StringIter last (off_last2 > s_str.size () ? s_str.end () : s_str.begin () + off_last2); s_str.replace (it_first, it_last, first, last); } - const std::size_t match = rw_match (cs.res, s_str.c_str(), cs.res_len); + const std::size_t match = + rw_match (tcase.res, s_str.c_str(), tcase.res_len); - rw_assert (match == cs.res_len, 0, cs.line, - "line %d. %s expected %{#*s}, got %{/*.*Gs}, " + rw_assert (match == tcase.res_len, 0, tcase.line, + "line %d. %{$FUNCALL} expected %{#*s}, got %{/*.*Gs}, " "difference at offset %zu for %s", - __LINE__, funcall, int (cs.res_len), cs.res, + __LINE__, int (tcase.res_len), tcase.res, int (sizeof (charT)), int (s_str.size ()), s_str.c_str (), match, itname); } @@ -1311,62 +1279,61 @@ void test_replace_range (const charT* wstr, const charT* warg, Traits*, - const TestCase &cs, - const char *funcall) + const TestCase &tcase) { - if (cs.bthrow) // this method doesn't throw + if (tcase.bthrow) // this method doesn't throw return; test_replace_range (wstr, warg, (Traits*)0, - InputIter<charT>(0, 0, 0), cs, funcall); + InputIter<charT>(0, 0, 0), tcase); // there is no need to call test_replace_range // for other iterators in this case - if (0 == cs.arg) + if (0 == tcase.arg) return; test_replace_range (wstr, warg, (Traits*)0, - ConstFwdIter<charT>(0, 0, 0), cs, funcall); + ConstFwdIter<charT>(0, 0, 0), tcase); test_replace_range (wstr, warg, (Traits*)0, - ConstBidirIter<charT>(0, 0, 0), cs, funcall); + ConstBidirIter<charT>(0, 0, 0), tcase); test_replace_range (wstr, warg, (Traits*)0, - ConstRandomAccessIter<charT>(0, 0, 0), cs, funcall); + ConstRandomAccessIter<charT>(0, 0, 0), tcase); } /**************************************************************************/ template <class charT, class Traits> void test_replace (charT, Traits*, - const TestCase &cs, - const char *funcall) + ReplaceOverload which, + const TestCase &tcase) { typedef std::allocator<charT> Allocator; typedef std::basic_string <charT, Traits, Allocator> TestString; typedef typename TestString::iterator StringIter; - const bool use_iters = (Replace (ptr) <= cs.which); + const bool use_iters = Replace (iter_iter_ptr) <= which; static charT wstr [LLEN]; static charT warg [LLEN]; - rw_widen (wstr, cs.str, cs.str_len); - rw_widen (warg, cs.arg, cs.arg_len); + rw_widen (wstr, tcase.str, tcase.str_len); + rw_widen (warg, tcase.arg, tcase.arg_len); // special processing for replace_range to exercise all iterators - if (Replace (range) == cs.which) { - test_replace_range (wstr, warg, (Traits*)0, cs, funcall); + if (Replace (iter_iter_range) == which) { + test_replace_range (wstr, warg, (Traits*)0, tcase); return; } - /* const */ TestString s_str (wstr, cs.str_len); - const TestString s_arg (warg, cs.arg_len); + /* const */ TestString s_str (wstr, tcase.str_len); + const TestString s_arg (warg, tcase.arg_len); std::size_t res_off = 0; - int first = use_iters ? cs.off : cs.str_len + 1; - int last = use_iters ? cs.off + cs.size : cs.str_len + 1; - std::size_t size = cs.size2 >= 0 ? cs.size2 : s_str.max_size () + 1; + int first = use_iters ? tcase.off : tcase.str_len + 1; + int last = use_iters ? tcase.off + tcase.size : tcase.str_len + 1; + std::size_t size = tcase.size2 >= 0 ? tcase.size2 : s_str.max_size () + 1; StringIter it_first (std::size_t (first) >= s_str.size () ? s_str.end () : s_str.begin () + first); @@ -1374,9 +1341,9 @@ s_str.end () : s_str.begin () + last); // string function argument - const charT* const arg_ptr = cs.arg ? warg : s_str.c_str (); - const TestString& arg_str = cs.arg ? s_arg : s_str; - const charT arg_val = make_char (char (cs.val), (charT*)0); + const charT* const arg_ptr = tcase.arg ? warg : s_str.c_str (); + const TestString& arg_str = tcase.arg ? s_arg : s_str; + const charT arg_val = make_char (char (tcase.val), (charT*)0); // address of returned reference const TestString* res_ptr = 0; @@ -1385,11 +1352,11 @@ // is some exception expected ? const char* expected = 0; - if (1 == cs.bthrow && !use_iters) + if (1 == tcase.bthrow && !use_iters) expected = exp_exceptions [1]; - if (2 == cs.bthrow && Replace (off_size_str_off_size) == cs.which) + if (2 == tcase.bthrow && Replace (size_size_str_size_size) == which) expected = exp_exceptions [1]; - if (3 == cs.bthrow && !use_iters) + if (3 == tcase.bthrow && !use_iters) expected = exp_exceptions [2]; const char* caught = 0; @@ -1398,54 +1365,54 @@ #else // if defined (_RWSTD_NO_EXCEPTIONS) - if (cs.bthrow) + if (tcase.bthrow) return; #endif // _RWSTD_NO_EXCEPTIONS - switch (cs.which) - { - case Replace (off_size_ptr): { - res_ptr = &s_str.replace (cs.off, cs.size, arg_ptr); + switch (which) { + case Replace (size_size_ptr): { + res_ptr = &s_str.replace (tcase.off, tcase.size, arg_ptr); break; } - case Replace (off_size_str): { - res_ptr = &s_str.replace (cs.off, cs.size, arg_str); + case Replace (size_size_str): { + res_ptr = &s_str.replace (tcase.off, tcase.size, arg_str); break; } - case Replace (off_size_ptr_size): { - res_ptr = &s_str.replace (cs.off, cs.size, arg_ptr, size); + case Replace (size_size_ptr_size): { + res_ptr = &s_str.replace (tcase.off, tcase.size, arg_ptr, size); break; } - case Replace (off_size_str_off_size): { - res_ptr = &s_str.replace (cs.off, cs.size, arg_str, cs.off2, size); + case Replace (size_size_str_size_size): { + res_ptr = &s_str.replace (tcase.off, tcase.size, arg_str, + tcase.off2, size); break; } - case Replace (off_size_size_val): { - res_ptr = &s_str.replace (cs.off, cs.size, size, arg_val); + case Replace (size_size_size_val): { + res_ptr = &s_str.replace (tcase.off, tcase.size, size, arg_val); break; } - case Replace (ptr): { + case Replace (iter_iter_ptr): { res_ptr = &s_str.replace (it_first, it_last, arg_ptr); break; } - case Replace (str): { + case Replace (iter_iter_str): { res_ptr = &s_str.replace (it_first, it_last, arg_str); break; } - case Replace (ptr_size): { + case Replace (iter_iter_ptr_size): { res_ptr = &s_str.replace (it_first, it_last, arg_ptr, size); break; } - case Replace (size_val): { + case Replace (iter_iter_size_val): { res_ptr = &s_str.replace (it_first, it_last, size, arg_val); break; } @@ -1458,24 +1425,27 @@ res_off = res_ptr - &s_str; // verify the returned value - rw_assert (0 == res_off, 0, cs.line, - "line %d. %s returned invalid reference, offset is %zu%", - __LINE__, funcall, res_off); + rw_assert (0 == res_off, 0, tcase.line, + "line %d. %{$FUNCALL} returned invalid reference, offset is %zu", + __LINE__, res_off); // verfiy that strings length are equal - rw_assert (cs.res_len == s_str.size (), 0, cs.line, - "line %d. %s expected %{#*s} with length %zu, got %{/*.*Gs} " - "with length %zu", __LINE__, funcall, int (cs.res_len), - cs.res, cs.res_len, int (sizeof (charT)), int (s_str.size ()), + rw_assert (tcase.res_len == s_str.size (), 0, tcase.line, + "line %d. %{$FUNCALL} expected %{#*s} with length %zu, " + "got %{/*.*Gs} with length %zu", + __LINE__, int (tcase.res_len), + tcase.res, tcase.res_len, int (sizeof (charT)), + int (s_str.size ()), s_str.c_str (), s_str.size ()); // verfiy that replace results match expected result - const std::size_t match = rw_match (cs.res, s_str.c_str(), cs.res_len); + const std::size_t match = + rw_match (tcase.res, s_str.c_str(), tcase.res_len); - rw_assert (match == cs.res_len, 0, cs.line, - "line %d. %s expected %{#*s}, got %{/*.*Gs}, " + rw_assert (match == tcase.res_len, 0, tcase.line, + "line %d. %{$FUNCALL} expected %{#*s}, got %{/*.*Gs}, " "difference at offset %zu", - __LINE__, funcall, int (cs.res_len), cs.res, + __LINE__, int (tcase.res_len), tcase.res, int (sizeof (charT)), int (s_str.size ()), s_str.c_str (), match); @@ -1496,32 +1466,29 @@ _RWSTD_UNUSED (should_throw); #endif // _RWSTD_NO_EXCEPTIONS - rw_assert (caught == expected, 0, cs.line, - "line %d. %s %{?}expected %s, caught %s" + rw_assert (caught == expected, 0, tcase.line, + "line %d. %{$FUNCALL} %{?}expected %s, caught %s" "%{:}unexpectedly caught %s%{;}", __LINE__, - funcall, 0 != expected, expected, caught, caught); + 0 != expected, expected, caught, caught); } /**************************************************************************/ static void -test_replace (const MemFun *pfid, const TestCase& cs, bool exc_safety_test) +test_replace (const MemFun &memfun, + const TestCase &tcase) { - // format the description of the function call including - // the values of arguments for use in diagnostics - char* const funcall = - StringMembers::format (pfid->cid_, pfid->tid_, - StringMembers::DefaultAllocator, - cs); + // exercise exception safety? + const bool exception_safety = -1 == tcase.bthrow; #undef TEST #define TEST(charT, Traits) \ - exc_safety_test ? \ - test_exceptions (charT (), (Traits*)0, cs, funcall) \ - : test_replace (charT (), (Traits*)0, cs, funcall) + exception_safety ? \ + test_exceptions (charT (), (Traits*)0, memfun.which_, tcase) \ + : test_replace (charT (), (Traits*)0, memfun.which_, tcase) - if (StringMembers::DefaultTraits == pfid->tid_) { - if (StringMembers::Char == pfid->cid_) + if (StringMembers::DefaultTraits == memfun.traits_id_) { + if (StringMembers::Char == memfun.char_id_) TEST (char, std::char_traits<char>); #ifndef _RWSTD_NO_WCHAR_T @@ -1531,103 +1498,17 @@ } else { - if (StringMembers::Char == pfid->cid_) + if (StringMembers::Char == memfun.char_id_) TEST (char, UserTraits<char>); #ifndef _RWSTD_NO_WCHAR_T - else if (StringMembers::WChar == pfid->cid_) + else if (StringMembers::WChar == memfun.char_id_) TEST (wchar_t, UserTraits<wchar_t>); #endif // _RWSTD_NO_WCHAR_T else TEST (UserChar, UserTraits<UserChar>); } - - std::free (funcall); -} - -/**************************************************************************/ - -static void -test_replace (const MemFun *pfid, const Test& test) -{ - rw_info (0, 0, 0, "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::%s", - pfid->cname_, pfid->tname_, pfid->aname_, test.funsig); - - if (StringMembers::opt_no_exception_safety) - rw_note (0, 0, 0, - "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::" - "%s exception safety test disabled", - pfid->cname_, pfid->tname_, pfid->aname_, test.funsig); - -#ifdef _RWSTD_NO_REPLACEABLE_NEW_DELETE - - else - rw_warn (0, 0, __LINE__, - "%s exception safety test: no replacable new and delete", - test.funsig); - -#endif //_RWSTD_NO_REPLACEABLE_NEW_DELETE - - for (std::size_t i = 0; i != test.case_count; ++i) { - - if (!rw_enabled (test.cases [i].line)) { - rw_note (0, 0, __LINE__, - "test on line %d disabled", test.cases [i].line); - continue; - } - - // do not exercise exceptions if they were disabled - if ( 0 != StringMembers::opt_no_exceptions - && 0 != test.cases [i].bthrow) - continue; - - // do not exercise exception safety if they were disabled - if ( 0 != StringMembers::opt_no_exception_safety - && -1 == test.cases [i].bthrow) - continue; - - test_replace (pfid, test.cases [i], -1 == test.cases [i].bthrow); - } -} - - -/**************************************************************************/ - -static void -run_test (const MemFun *pfid) -{ - if ( StringMembers::UserTraits == pfid->tid_ - && StringMembers::opt_no_user_traits) { - rw_note (1 < StringMembers::opt_no_user_traits++, 0, 0, - "user defined traits test disabled"); - } - else if ( StringMembers::DefaultTraits == pfid->tid_ - && StringMembers::opt_no_char_traits) { - rw_note (1 < StringMembers::opt_no_char_traits++, 0, 0, - "char_traits test disabled"); - } - else { - - if (StringMembers::opt_no_exceptions) - rw_note (1 < StringMembers::opt_no_exceptions++, 0, 0, - "string::replace exceptions tests disabled"); - - static const std::size_t ntests = sizeof tests / sizeof *tests; - - for (std::size_t i = 0; i < ntests; i++) { - - int tmp = tests [i].cases [0].which - StringMembers::replace_first; - - if (Disabled (tmp)) - rw_note (0, 0, 0, - "std::basic_string<%s, %s<%1$s>, %s<%1$s>>::" - "%s test disabled", pfid->cname_, pfid->tname_, - pfid->aname_, tests [i].funsig); - else - test_replace (pfid, tests [i]); - } - } } /**************************************************************************/ @@ -1641,53 +1522,30 @@ LSTR [i] = 'x'; } - if (rw_enabled ("char")) { + static const StringMembers::Test + tests [] = { - MemFun fid (StringMembers::Char, "char", - StringMembers::DefaultTraits, 0); - - fid.tname_ = "char_traits"; - - run_test (&fid); - - fid.tid_ = StringMembers::UserTraits; - fid.tname_ = "UserTraits"; - - run_test (&fid); - } - else - rw_note (0, 0, 0, "string::%s char tests disabled", method_name); - - if (rw_enabled ("wchar_t")) { - - MemFun fid (StringMembers::WChar, "wchar_t", - StringMembers::DefaultTraits, 0); - - fid.tname_ = "char_traits"; - - run_test (&fid); - - fid.tid_ = StringMembers::UserTraits; - fid.tname_ = "UserTraits"; - - run_test (&fid); - } - else - rw_note (0, 0, 0, "string::%s wchar tests disabled", method_name); +#undef TEST +#define TEST(tag) { \ + StringMembers::replace_ ## tag, tag ## _test_cases, \ + sizeof tag ## _test_cases / sizeof *tag ## _test_cases \ + } + + TEST (size_size_ptr), + TEST (size_size_str), + TEST (size_size_ptr_size), + TEST (size_size_str_size_size), + TEST (size_size_size_val), + TEST (iter_iter_ptr), + TEST (iter_iter_str), + TEST (iter_iter_ptr_size), + TEST (iter_iter_size_val), + TEST (iter_iter_range) + }; - if (StringMembers::opt_no_user_char) { - rw_note (0, 0, 0, "user defined chars test disabled"); - } - else { - MemFun fid (StringMembers::UChar, "UserChar", - StringMembers::UserTraits, 0); - fid.tname_ = "UserTraits"; - run_test (&fid); - } + const std::size_t test_count = sizeof tests / sizeof *tests; - // silence a bogus EDG eccp remark #550-D: - // variable "exp_exceptions" was set but never used - _RWSTD_UNUSED (exp_exceptions); + StringMembers::run_test (test_replace, tests, test_count); return 0; } @@ -1705,11 +1563,11 @@ "|-no-exceptions# " "|-no-exception-safety# " - "|-no-replace-off-size-ptr# " - "|-no-replace-off-size-str# " - "|-no-replace-off_size-ptr-size# " - "|-no-replace-off-size-str-off-size# " - "|-no-replace-off-size-size-val# " + "|-no-replace-size-size-ptr# " + "|-no-replace-size-size-str# " + "|-no-replace-size-size-ptr-size# " + "|-no-replace-size-size-str-size-size# " + "|-no-replace-size-size-size-val# " "|-no-replace-ptr# " "|-no-replace-str# " "|-no-replace-ptr-size# " @@ -1722,16 +1580,16 @@ &StringMembers::opt_no_exceptions, &StringMembers::opt_no_exception_safety, - &Disabled (Replace (off_size_ptr)), - &Disabled (Replace (off_size_str)), - &Disabled (Replace (off_size_ptr_size)), - &Disabled (Replace (off_size_str_off_size)), - &Disabled (Replace (off_size_size_val)), - &Disabled (Replace (ptr)), - &Disabled (Replace (str)), - &Disabled (Replace (ptr_size)), - &Disabled (Replace (size_val)), - &Disabled (Replace (range)), + &Disabled (Replace (size_size_ptr)), + &Disabled (Replace (size_size_str)), + &Disabled (Replace (size_size_ptr_size)), + &Disabled (Replace (size_size_str_size_size)), + &Disabled (Replace (size_size_size_val)), + &Disabled (Replace (iter_iter_ptr)), + &Disabled (Replace (iter_iter_str)), + &Disabled (Replace (iter_iter_ptr_size)), + &Disabled (Replace (iter_iter_size_val)), + &Disabled (Replace (iter_iter_range)), // sentinel (void*)0);
