You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stdcxx.apache.org by se...@apache.org on 2005/12/23 23:36:40 UTC
svn commit: r358878 - /incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp
Author: sebor
Date: Fri Dec 23 14:36:36 2005
New Revision: 358878
URL: http://svn.apache.org/viewcvs?rev=358878&view=rev
Log:
2005-12-23 Anton Pevtsov <an...@moscow.vdiweb.com>
Martin Sebor <se...@roguewave.com>
STDCXX-4
* 25.replace.cpp: New test exercising lib.alg.replace.
Added:
incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp (with props)
Added: incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp?rev=358878&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp (added)
+++ incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp Fri Dec 23 14:36:36 2005
@@ -0,0 +1,682 @@
+/***************************************************************************
+ *
+ * 25.replace.cpp - test exercising 25.2.4 [lib.alg.replace]
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Copyright (c) 1994-2005 Quovadx, Inc., acting through its Rogue Wave
+ * Software division. 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 <algorithm> // for replace(), replace_copy()
+#include <cstring> // for strlen()
+#include <cstdlib> // for free(), size_t
+
+#include <alg_test.h>
+#include <driver.h> // for rw_test()
+#include <printf.h> // for rw_asnprintf()
+
+/**************************************************************************/
+
+_RWSTD_NAMESPACE (std) {
+
+// disable explicit instantiation for compilers (like MSVC)
+// that can't handle it
+#ifndef _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+template
+void replace (FwdIter<eq_comp<assign<base<> > > >,
+ FwdIter<eq_comp<assign<base<> > > >,
+ const eq_comp<assign<base<> > >&,
+ const eq_comp<assign<base<> > >&);
+
+template
+void replace_if (FwdIter<assign<base<> > > ,
+ FwdIter<assign<base<> > > ,
+ predicate<assign<base<> > > ,
+ const assign<base<> > &);
+
+template
+OutputIter<eq_comp<assign<base<> > > >
+replace_copy (InputIter<eq_comp<assign<base<> > > >,
+ InputIter<eq_comp<assign<base<> > > >,
+ OutputIter<eq_comp<assign<base<> > > >,
+ const eq_comp<assign<base<> > >&,
+ const eq_comp<assign<base<> > >&);
+
+template
+OutputIter<assign<base<> > >
+replace_copy_if (InputIter<assign<base<> > > ,
+ InputIter<assign<base<> > > ,
+ OutputIter<assign<base<> > > ,
+ predicate<assign<base<> > > ,
+ const assign<base<> > &);
+
+#endif // _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+} // namespace std
+
+/**************************************************************************/
+
+// names of tested functions
+const char* const fnames[] = { "replace", "replace_copy" };
+const char* const fnames_if[] = { "replace_if", "replace_copy_if" };
+
+// tags to select replace or replace_copy at compile time
+struct ReplaceTag {
+ enum { fname_inx = 0 };
+ int use_predicate;
+};
+
+struct ReplaceCopyTag {
+ enum { fname_inx = 1 };
+ int use_predicate;
+};
+
+// used as a dummy template argument to test functions exercising replace()
+// and replace_if() (to differentiate from replace_copy() and replace_copy_if())
+struct NoIterator { };
+const char* type_name (NoIterator, const X*)
+{
+ return 0;
+}
+
+typedef unsigned char UChar;
+
+/**************************************************************************/
+
+const char nul_char = '\0';
+
+template <class T>
+class ToString
+{
+public:
+ ToString (const T *first, const T *last, int pos, bool use_id = false)
+ : str_ (0) {
+
+ std::size_t buf_sz = 0;
+
+ if (first > last) {
+ rw_asnprintf (&str_, &buf_sz, "%s", "bad range");
+ return;
+ }
+
+ char* res = (char*)&nul_char;
+ char* tmp = 0;
+
+ for (const T *cur = first; cur != last; ++cur) {
+ rw_asnprintf (&tmp, &buf_sz,
+ "%s%{?}>%{;}%{?}%d:%{;}%{lc}%{?}<%{;}",
+ res,
+ cur - first == pos, // '>'
+ use_id, cur->id_, // "<id>:"
+ cur->val_, // <val>
+ cur - first == pos); // '<'
+
+ if (res != &nul_char)
+ std::free (res);
+
+ res = tmp;
+ tmp = 0;
+ }
+
+ str_ = res;
+ }
+
+ ~ToString () {
+ if (str_ != &nul_char)
+ std::free (str_);
+ }
+
+ operator const char* () const {
+ return str_;
+ }
+
+private:
+
+ char* str_;
+};
+
+/**************************************************************************/
+
+// predicate used as an argument to replace_if() and replace_copy_if()
+template <class T>
+struct EqualityPredicate
+{
+ static std::size_t funcalls_;
+
+ EqualityPredicate (const T &val, int /* dummy */)
+ : val_ (val) {
+ funcalls_ = 0;
+ }
+
+ class ConvertibleToBool {
+ bool result_;
+ public:
+ ConvertibleToBool (bool res): result_ (res) { /* empty */ }
+ operator bool() const { return result_; }
+ };
+
+ // return a type other than bool but one that is implicitly
+ // convertible to bool to detect incorrect assumptions
+ ConvertibleToBool operator() (const T &arg) {
+ ++funcalls_;
+ return ConvertibleToBool (arg == val_);
+ }
+
+private:
+ void operator= (EqualityPredicate&);
+ const T &val_;
+};
+
+template <class T>
+std::size_t EqualityPredicate<T>::funcalls_;
+
+/**************************************************************************/
+
+// exercises std::replace() and std::replace_if()
+template <class Iterator, class T, class Predicate>
+void test_replace (int line,
+ const char *src, // source sequence
+ char val, // value to replace
+ char new_val, // value to replace it with
+ Iterator dummy, // not used
+ NoIterator,
+ const T*,
+ const Predicate*,
+ ReplaceTag tag) // replace() or replace_if()
+{
+ static const char* const itname = type_name (Iterator (), (T*)0);
+ static const char* const fname = tag.use_predicate ?
+ fnames_if [tag.fname_inx] : fnames [tag.fname_inx];
+
+ // compute the length of the source sequence
+ const std::size_t nsrc = std::strlen (src);
+
+ // construct a sequence of `nsrc' elements to pass to replace
+ // (make sure there's always at least 1 element, even if the
+ // sequence is otherwise empty, to avoid undefined behavior
+ // when de-referencing xsrc[0] in inactive diagnostic messages)
+ T* const xsrc = T::from_char (src, nsrc + 1);
+ T* const xsrc_end = xsrc + nsrc;
+
+ // construct an element to replace
+ T to_replace;
+ to_replace.val_ = val;
+
+ // construct an element to replace it with
+ T replace_with;
+ replace_with.val_ = new_val;
+
+ // construct a predicate object (used with replace_if() only)
+ const Predicate pred (to_replace, 0);
+
+ // construct iterators pointing to the beginning and end
+ // of the source sequence
+ const Iterator first = make_iter (xsrc, xsrc, xsrc_end, dummy);
+ const Iterator last = make_iter (xsrc_end, xsrc_end, xsrc_end, dummy);
+
+ // zero out predicate counters
+ T::n_total_op_eq_ = 0;
+
+ // call replace() or replace_if()
+ if (tag.use_predicate)
+ std::replace_if (first, last, pred, replace_with);
+ else
+ std::replace (first, last, to_replace, replace_with);
+
+ // verify that the value to be replaced has been replaced
+ // with the replacement value
+ bool success = true;
+ std::size_t i = 0;
+ for ( ; i != nsrc; ++i) {
+ success = to_replace.val_ != xsrc [i].val_;
+ if (!success)
+ break;
+ }
+
+ rw_assert (success, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c', '%c') ==> \"%s\"; "
+ "unexpected element value %c",
+ __LINE__, fname, itname, src, val, new_val,
+ (const char*) ToString<T>(xsrc, xsrc_end, i),
+ src [i]);
+
+ // check the id (not just the value) of the matching element
+ // to make sure it has really been replaced
+ for (i = 0; i != nsrc; ++i) {
+
+ success =
+ val != src [i]
+ || val == src [i]
+ && replace_with.origin_ == xsrc [i].origin_;
+
+ if (!success)
+ break;
+ }
+
+ rw_assert (success, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c', '%c') ==> \"%s\"; "
+ "failed to replace element %zu: "
+ "origin %d (%d, %d), expected %d (%d)",
+ __LINE__, fname, itname, src, val, new_val,
+ (const char*)ToString<T>(xsrc, xsrc_end, i),
+ i, xsrc [i].origin_, xsrc [i].id_, xsrc [i].src_id_,
+ replace_with.origin_, replace_with.id_);
+
+ // verify the number of applications of the predicate: p 25.2.4.3
+ if (tag.use_predicate) {
+ rw_assert (pred.funcalls_ == nsrc, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') called "
+ "Predicate::operator() %zu times, %zu expected",
+ __LINE__, fname, itname, src, val,
+ pred.funcalls_, nsrc);
+ }
+ else {
+ rw_assert (T::n_total_op_eq_ == nsrc, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') called "
+ "T::operator< %zu times, %zu expected",
+ __LINE__, fname, itname, src, val,
+ T::n_total_op_eq_, nsrc);
+ }
+
+ delete[] xsrc;
+}
+
+/**************************************************************************/
+
+// exercises std::replace_copy()
+template <class Iterator, class OutputIterator, class T, class Predicate>
+void test_replace (int line,
+ const char *src, // source sequence
+ char val, // value to replace
+ char new_val, // value to replace it with
+ Iterator it,
+ OutputIterator dummy,
+ const T*,
+ const Predicate*,
+ ReplaceCopyTag tag) // replace_copy or replace_copy_if
+{
+ static const char* const itname = type_name (it, (T*)0);
+ static const char* const fname = tag.use_predicate ?
+ fnames_if [tag.fname_inx] : fnames [tag.fname_inx];
+
+ const std::size_t nsrc = std::strlen (src);
+
+ // construct a sequence of `nsrc' elements to pass to replace
+ // (make sure there's always at least 1 element, even if the
+ // sequence is otherwise empty, to avoid undefined behavior
+ // when de-referencing xsrc[0] in inactive diagnostic messages)
+ T* const xsrc = T::from_char (src, nsrc + 1);
+ T* const xdst = T::from_char (src, nsrc + 1);
+
+ T* const xsrc_end = xsrc + nsrc;
+ T* const xdst_end = xdst + nsrc;
+
+ T to_replace;
+ to_replace.val_ = val;
+
+ T replace_with;
+ replace_with.val_ = new_val;
+
+ const Predicate pred (to_replace, 0);
+
+ const Iterator first = make_iter (xsrc, xsrc, xsrc_end, it);
+ const Iterator last = make_iter (xsrc_end, xsrc_end, xsrc_end, it);
+
+ const OutputIterator result = make_iter (xdst, xdst, xdst_end, dummy);
+
+ // zero out predicate counters
+ T::n_total_op_eq_ = 0;
+
+ const OutputIterator end = tag.use_predicate
+ ? std::replace_copy_if (first, last, result, pred, replace_with)
+ : std::replace_copy (first, last, result, to_replace, replace_with);
+
+ // verify that the returned iterator is set as expected
+ rw_assert (end.cur_ == result.cur_ + nsrc, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') == %p, "
+ "got %p", __LINE__, fname, itname, src, val,
+ first.cur_ + nsrc, end.cur_);
+
+ // verify that the value to be replaced does not appear anywhere
+ // in the range [result, end)
+ bool success = true;
+ std::size_t i = 0;
+ for ( ; i != nsrc; ++i) {
+ success = UChar (val) != xdst [i].val_;
+ if (!success)
+ break;
+ }
+
+ rw_assert (success, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') ==> \"%s\"; "
+ "unexpected element value %c",
+ __LINE__, fname, itname, src, val,
+ (const char*)ToString<T>(xdst, xdst_end, i), src [i]);
+
+ // check the id (not just the value) of the matching element
+ // to make sure it has really been copied
+ for (i = 0; i != nsrc; ++i) {
+ success =
+ val != src [i]
+ || val == src [i]
+ && replace_with.origin_ == xdst [i].origin_;
+
+ if (!success)
+ break;
+ }
+
+ rw_assert (success, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c', '%c') ==> \"%s\"; "
+ "failed to copy and replace element %zu: "
+ "origin %d (%d, %d), expected %d (%d)",
+ __LINE__, fname, itname, src, val, new_val,
+ (const char*)ToString<T>(xdst, xdst_end, i),
+ i, xdst [i].origin_, xdst [i].id_, xdst [i].src_id_,
+ replace_with.origin_, replace_with.id_);
+
+ // verify the number of applications of the predicate: p 25.2.4.7
+ if (tag.use_predicate) {
+ rw_assert (pred.funcalls_ == nsrc, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') called "
+ "Predicate::operator() %zu times, %zu expected",
+ __LINE__, fname, itname, src, val,
+ pred.funcalls_, nsrc);
+ }
+ else {
+ rw_assert (T::n_total_op_eq_ == nsrc, 0, line,
+ "line %d: %s<%s>(\"%s\", ..., '%c') called "
+ "T::operator< %zu times, %zu expected",
+ __LINE__, fname, itname, src, val,
+ T::n_total_op_eq_, nsrc);
+ }
+
+ delete[] xsrc;
+ delete[] xdst;
+}
+
+/**************************************************************************/
+
+// exercises all four function templates
+template <class Iterator1, class Iterator2, class T,
+ class Predicate, class Tag>
+void test_replace (Iterator1 it1, Iterator2 it2, const T*,
+ const Predicate* pred, Tag tag)
+{
+ static const char* const it1name = type_name (it1, (T*)0);
+ static const char* const it2name = type_name (it2, (T*)0);
+
+ if (tag.fname_inx) { // replace_copy(), replace_copy_if()
+ rw_info (0, 0, 0,
+ "std::%s (%s, %s, %s, %s, const T&)",
+ tag.use_predicate ? "replace_copy_if" : "replace_copy",
+ it1name, it1name, it2name,
+ tag.use_predicate ? "UnaryPredicate" : "const T&");
+ }
+ else { // replace, replace_if()
+ rw_info (0, 0, 0,
+ "std::%s (%s, %s, %s, const T&)",
+ tag.use_predicate ? "replace_if" : "replace",
+ it1name, it1name,
+ tag.use_predicate ? "UnaryPredicate" : "const T&");
+ }
+
+
+#define TEST(src, val, new_val) \
+ test_replace (__LINE__, src, val, new_val, it1, it2, (T*)0, pred, tag)
+
+ // +----------------------- original sequence
+ // | +------- value to replace
+ // | | +- value to replace it with
+ // | | |
+ // v v v
+ TEST ("", 'a', 'b');
+ TEST ("a", 'a', 'b');
+ TEST ("aa", 'a', 'b');
+ TEST ("aaa", 'a', 'b');
+ TEST ("aaaa", 'a', 'b');
+ TEST ("aaaaa", 'a', 'b');
+ TEST ("aaaaaa", 'a', 'b');
+ TEST ("aaaaaaa", 'a', 'b');
+ TEST ("aaaaaaaa", 'a', 'b');
+ TEST ("aaaaaaaaa", 'a', 'b');
+ TEST ("aaaaaaaaaa", 'a', 'b');
+
+ TEST ("b", 'a', 'b');
+ TEST ("bb", 'a', 'b');
+ TEST ("ba", 'a', 'b');
+ TEST ("ab", 'a', 'b');
+ TEST ("abc", 'a', 'b');
+ TEST ("bac", 'a', 'b');
+ TEST ("bca", 'a', 'b');
+ TEST ("aba", 'a', 'b');
+ TEST ("abab", 'a', 'b');
+ TEST ("ababa", 'a', 'b');
+ TEST ("bababa", 'a', 'b');
+ TEST ("bababab", 'a', 'b');
+ TEST ("babababa", 'a', 'b');
+ TEST ("bbbbbbbbb", 'a', 'b');
+}
+
+/**************************************************************************/
+
+/* extern */ int rw_opt_no_replace; // --no-replace
+/* extern */ int rw_opt_no_replace_if; // --no-replace_if
+/* extern */ int rw_opt_no_replace_copy; // --no-replace_copy
+/* extern */ int rw_opt_no_replace_copy_if; // --no-replace_copy_if
+/* extern */ int rw_opt_no_input_iter; // --no-InputIterator
+/* extern */ int rw_opt_no_output_iter; // --no-OutputIterator
+/* extern */ int rw_opt_no_fwd_iter; // --no-ForwardIterator
+/* extern */ int rw_opt_no_bidir_iter; // --no-BidirectionalIterator
+/* extern */ int rw_opt_no_rnd_iter; // --no-RandomAccessIterator
+
+template <class T, class Predicate, class Tag>
+void test_replace (const T* , const Predicate* pred, Tag tag)
+{
+ rw_info (0, 0, 0,
+ "template <class ForwardIterator, class T> "
+ "std::%s (ForwardIterator, ForwardIterator, "
+ "%s, const T&)",
+ tag.use_predicate ? "replace_if" : "replace",
+ tag.use_predicate ? "Predicate" : "const T&");
+
+ if (rw_opt_no_fwd_iter) {
+ rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+ }
+ else {
+ test_replace (FwdIter<T>(), NoIterator (), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_bidir_iter) {
+ rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+ }
+ else {
+ test_replace (BidirIter<T>(), NoIterator (), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_rnd_iter) {
+ rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+ }
+ else {
+ test_replace (RandomAccessIter<T>(), NoIterator (), (T*)0, pred, tag);
+ }
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_replace (const T* )
+{
+ const ReplaceTag replace_tag = { false };
+ const ReplaceTag replace_if_tag = { true };
+
+ if (rw_opt_no_replace) {
+ rw_note (0, __FILE__, __LINE__, "std::replace test disabled");
+ }
+ else {
+ const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 0;
+ test_replace((T*)0, pred, replace_tag);
+ }
+
+ if (rw_opt_no_replace_if) {
+ rw_note (0, __FILE__, __LINE__, "std::replace_if test disabled");
+ }
+ else {
+ const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 1;
+ test_replace((T*)0, pred, replace_if_tag);
+ }
+}
+
+/**************************************************************************/
+
+template <class InputIterator, class T, class Predicate, class Tag>
+void test_replace_copy (const InputIterator& iter, const T*,
+ const Predicate* pred, Tag tag)
+{
+ if (rw_opt_no_output_iter) {
+ rw_note (0, __FILE__, __LINE__, "OutputIterator test disabled");
+ }
+ else {
+ test_replace (iter, OutputIter<T>(0, 0, 0), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_fwd_iter) {
+ rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+ }
+ else {
+ test_replace (iter, FwdIter<T>(), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_bidir_iter) {
+ rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+ }
+ else {
+ test_replace (iter, BidirIter<T>(), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_rnd_iter) {
+ rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+ }
+ else {
+ test_replace (iter, RandomAccessIter<T>(), (T*)0, pred, tag);
+ }
+}
+
+/**************************************************************************/
+
+template <class T, class Predicate, class Tag>
+void test_replace_copy (const T*, const Predicate* pred, Tag tag)
+{
+ rw_info (0, 0, 0,
+ "template "
+ "<class InputIterator, class OutputIterator, class T> "
+ "std::%s (InputIterator, InputIterator, "
+ "OutputIterator, %s, const T&)",
+ tag.use_predicate ? "replace_copy_if" : "replace_copy",
+ tag.use_predicate ? "Predicate" : "const T&");
+
+ if (rw_opt_no_input_iter) {
+ rw_note (0, __FILE__, __LINE__, "InputIterator test disabled");
+ }
+ else {
+ test_replace_copy (InputIter<T>(0, 0, 0), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_fwd_iter) {
+ rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+ }
+ else {
+ test_replace_copy (FwdIter<T>(), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_bidir_iter) {
+ rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+ }
+ else {
+ test_replace_copy (BidirIter<T>(), (T*)0, pred, tag);
+ }
+
+ if (rw_opt_no_rnd_iter) {
+ rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+ }
+ else {
+ test_replace_copy (RandomAccessIter<T>(), (T*)0, pred, tag);
+ }
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_replace_copy (const T* )
+{
+ const ReplaceCopyTag replace_copy_tag = { false };
+ const ReplaceCopyTag replace_copy_if_tag = { true };
+
+ if (rw_opt_no_replace_copy) {
+ rw_note (0, __FILE__, __LINE__, "std::replace_copy test disabled");
+ }
+ else {
+ const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 0;
+ test_replace_copy ((T*)0, pred, replace_copy_tag);
+ }
+
+ if (rw_opt_no_replace_copy_if) {
+ rw_note (0, __FILE__, __LINE__, "std::replace_copy_if test disabled");
+ }
+ else {
+ const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*)1;
+ test_replace_copy ((T*)0, pred, replace_copy_if_tag);
+ }
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char*[])
+{
+ test_replace ((X*)0);
+
+ test_replace_copy ((X*)0);
+
+ return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+ return rw_test (argc, argv, __FILE__,
+ "lib.alg.replace",
+ 0 /* no comment */,
+ run_test,
+ "|-no-replace# "
+ "|-no-replace_if# "
+ "|-no-replace_copy# "
+ "|-no-replace_copy_if# "
+ "|-no-InputIterator# "
+ "|-no-OutputIterator# "
+ "|-no-ForwardIterator# "
+ "|-no-BidirectionalIterator# "
+ "|-no-RandomAccessIterator#",
+ &rw_opt_no_replace,
+ &rw_opt_no_replace_if,
+ &rw_opt_no_replace_copy,
+ &rw_opt_no_replace_copy_if,
+ &rw_opt_no_input_iter,
+ &rw_opt_no_output_iter,
+ &rw_opt_no_fwd_iter,
+ &rw_opt_no_bidir_iter,
+ &rw_opt_no_rnd_iter);
+}
Propchange: incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/algorithms/25.replace.cpp
------------------------------------------------------------------------------
svn:keywords = Id