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/07 03:42:17 UTC
svn commit: r354672 -
/incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp
Author: sebor
Date: Tue Dec 6 18:42:13 2005
New Revision: 354672
URL: http://svn.apache.org/viewcvs?rev=354672&view=rev
Log:
2005-12-06 Anton Pevtsov <an...@moscow.vdiweb.com>
Martin Sebor <se...@roguewave.com>
STDCXX-4
* 25.find.first.cpp: New test exercising lib.alg.find.first.of.
Added:
incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp (with props)
Added: incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp?rev=354672&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp (added)
+++ incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp Tue Dec 6 18:42:13 2005
@@ -0,0 +1,359 @@
+/***************************************************************************
+ *
+ * find.first.cpp - test exercising 25.1.4 [lib.alg.find.first.of]
+ *
+ * $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 find_first_of
+#include <cstring> // for size_t, strlen()
+
+#include <alg_test.h>
+#include <driver.h> // for rw_test
+
+/**************************************************************************/
+
+_RWSTD_NAMESPACE (std) {
+
+#ifndef _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+template
+FwdIter<eq_comp<base<> > >
+find_first_of (FwdIter<eq_comp<base<> > >, FwdIter<eq_comp<base<> > >,
+ FwdIter<eq_comp<base<> > >, FwdIter<eq_comp<base<> > >);
+
+template
+FwdIter<eq_comp<base<> > >
+find_first_of (FwdIter<eq_comp<base<> > >, FwdIter<eq_comp<base<> > >,
+ FwdIter<eq_comp<base<> > >, FwdIter<eq_comp<base<> > >,
+ binary_predicate<eq_comp<base<> > >);
+
+#endif // _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+} // namespace std
+
+/**************************************************************************/
+
+template <class T, class U>
+struct EqualityPredicate
+{
+ static std::size_t funcalls_;
+
+ // dummy arguments provided to prevent the class
+ // from being default constructible
+ EqualityPredicate (T* /* dummy */, U* /* dummy */) {
+ funcalls_ = 0;
+ }
+
+ // return a type other than bool but one that is implicitly
+ // convertible to bool to detect incorrect assumptions
+ class ConvertibleToBool {
+ bool result_;
+ public:
+ ConvertibleToBool (bool res): result_ (res) { /* empty */ }
+ operator bool() const { return result_; }
+ };
+
+ ConvertibleToBool operator() (const T &x, const U &y) /* non-const */ {
+ ++funcalls_;
+ return x == y;
+ }
+};
+
+template <class T, class U>
+std::size_t EqualityPredicate<T, U>::funcalls_;
+
+/**************************************************************************/
+
+// used to initialize an array of objects of type T
+static const char *tinit_begin;
+
+int tinit ()
+{
+ typedef unsigned char UChar;
+
+ return UChar (*tinit_begin++);
+}
+
+
+// exercises std::find_end()
+template <class ForwardIterator1, class ForwardIterator2,
+ class Predicate, class T>
+void do_test (int line, // line number of test case
+ const char *src, // source sequence
+ const char *fseq, // sequence to be found
+ std::size_t resoff, // offset of result
+ ForwardIterator1 &dummy_iter1,
+ ForwardIterator2 &dummy_iter2,
+ const T*,
+ const Predicate *pred)
+{
+ static const char* const it1name = type_name (dummy_iter1, (T*)0);
+ static const char* const it2name = type_name (dummy_iter2, (T*)0);
+ static const char* const pname = pred ? "Predicate" : "operator==";
+
+ const std::size_t nsrc = std::strlen (src);
+ const std::size_t nfseq = std::strlen (fseq);
+
+ if (std::size_t (-1) == resoff)
+ resoff = nsrc;
+
+ // have the T default ctor initialize objects from `src'
+ tinit_begin = src;
+ T::gen_ = tinit;
+
+ T* const tsrc = new T [nsrc];
+
+ T* const src_begin = tsrc;
+ T* const src_end = tsrc + nsrc;
+
+ // have the T default ctor initialize sequence to be found
+ tinit_begin = fseq;
+
+ T* const tfseq = new T [nfseq];
+
+ T* const fseq_begin = tfseq;
+ T* const fseq_end = tfseq + nfseq;
+
+ // create iterators
+ const ForwardIterator1 first1 =
+ make_iter (src_begin, src_begin, src_end, dummy_iter1);
+
+ const ForwardIterator1 last1 =
+ make_iter (src_end, src_begin, src_end, dummy_iter1);
+
+ const ForwardIterator2 first2 =
+ make_iter (fseq_begin, fseq_begin, fseq_end, dummy_iter2);
+
+ const ForwardIterator2 last2 =
+ make_iter (fseq_end, fseq_begin, fseq_end, dummy_iter2);
+
+ // compute the number of invocations of the operator==()
+ std::size_t last_n_op_assign = T::n_total_op_assign_;
+
+ const Predicate fun((T*)0, (T*)0); // dummy arguments
+
+ const ForwardIterator1 res = pred ?
+ std::find_first_of (first1, last1, first2, last2, fun)
+ : std::find_first_of (first1, last1, first2, last2);
+
+ // silence a bogus EDG eccp remark #550-D:
+ // variable "res" was set but never used
+ _RWSTD_UNUSED (res);
+
+ if (!rw_assert (res.cur_ == first1.cur_ + resoff, 0, line,
+ "line %d: find_first_of<%s, %s>(it = \"%s\", \"%s\")"
+ " == (it + %zu), got (it + %td)",
+ __LINE__, it1name, it2name, src, fseq,
+ resoff, res.cur_ - first1.cur_)) {
+ delete[] tsrc;
+ delete[] tfseq;
+ return;
+ }
+
+ const std::size_t npreds = pred ?
+ fun.funcalls_ : T::n_total_op_assign_ - last_n_op_assign;
+
+ rw_assert (npreds <= nfseq * nsrc, 0, line,
+ "line %d: find_first_of<%s, %s>(it = \"%s\", \"%s\")"
+ "%s invoked %zu times, expected no more than %td",
+ __LINE__, it1name, it2name, src, fseq, pname,
+ npreds, nfseq * nsrc);
+
+ delete[] tsrc;
+ delete[] tfseq;
+}
+
+/**************************************************************************/
+
+template <class ForwardIterator1, class ForwardIterator2,
+ class Predicate, class T>
+void run_tests (const ForwardIterator1 &dummy_iter1,
+ const ForwardIterator2 &dummy_iter2,
+ const T*,
+ const Predicate *pred)
+{
+ static const char* const it1name = type_name (dummy_iter1, (T*)0);
+ static const char* const it2name = type_name (dummy_iter2, (T*)0);
+
+ rw_info (0, 0, 0,
+ "%s std::find_first_of (%1$s, %1$s, %s, %2$s%{?}, %s%{;})",
+ it1name, it2name, 0 != pred, "Predicate");
+
+#define TEST(src, fnd, off_res) \
+ do_test (__LINE__, src, fnd, std::size_t (off_res), \
+ dummy_iter1, dummy_iter2, (X*)0, pred)
+
+ // +------------------ subject sequence
+ // | +--- sequence to be found
+ // | |
+ // | | +-- offset of returned iterator,
+ // | | | -1 denotes the end of sequence
+ // v v v
+ TEST ("abcdefghijk", "a", 0);
+ TEST ("abcdefghijk", "b", 1);
+ TEST ("abcdefghijk", "c", 2);
+ TEST ("abcdefghijk", "d", 3);
+ TEST ("abcdefghijk", "e", 4);
+ TEST ("abcdefghijk", "f", 5);
+ TEST ("abcdefghijk", "g", 6);
+ TEST ("abcdefghijk", "h", 7);
+ TEST ("abcdefghijk", "i", 8);
+ TEST ("abcdefghijk", "j", 9);
+ TEST ("abcdefghijk", "k", 10);
+
+ TEST ("aabcdefghijk", "a", 0);
+ TEST ("abbcdefghijk", "b", 1);
+ TEST ("abccdefghijk", "c", 2);
+ TEST ("abcddefghijk", "d", 3);
+ TEST ("abcdeefghijk", "e", 4);
+ TEST ("abcdeffghijk", "f", 5);
+ TEST ("abcdefgghijk", "g", 6);
+ TEST ("abcdefghhijk", "h", 7);
+ TEST ("abcdefghijjk", "i", 8);
+ TEST ("abcdefghijjk", "j", 9);
+ TEST ("abcdefghijkk", "k", 10);
+
+ TEST ("bbcdefghijk", "ab", 0);
+ TEST ("accdefghijk", "bc", 1);
+ TEST ("abddefghijk", "cd", 2);
+ TEST ("abceefghijk", "de", 3);
+ TEST ("abcdffghijk", "ef", 4);
+ TEST ("abcdegghijk", "fg", 5);
+ TEST ("abcdefhhijk", "gh", 6);
+ TEST ("abcdefgiijk", "hi", 7);
+ TEST ("abcdefghjjk", "ij", 8);
+ TEST ("abcdefghikk", "jk", 9);
+
+ TEST ("bbcdefghijk", "a", -1);
+ TEST ("accdefghijk", "b", -1);
+ TEST ("abddefghijk", "c", -1);
+ TEST ("abceefghijk", "d", -1);
+ TEST ("abcdffghijk", "e", -1);
+ TEST ("abcdegghijk", "f", -1);
+ TEST ("abcdefhhijk", "g", -1);
+ TEST ("abcdefgiijk", "h", -1);
+ TEST ("abcdefghjjk", "i", -1);
+ TEST ("abcdefghikk", "j", -1);
+
+ TEST ("", "a", -1);
+ TEST ("abcdefghijk", "", -1);
+}
+
+
+/**************************************************************************/
+
+/* 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
+/* extern */ int rw_opt_no_predicate; // --no-Predicate
+
+
+template <class ForwardIterator, class Predicate, class T>
+void run_test (const ForwardIterator &dummy, T*, Predicate* pred)
+{
+ if (rw_opt_no_fwd_iter) {
+ rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+ }
+ else {
+ run_tests (dummy, FwdIter<T>(), (T*)0, pred);
+ }
+
+ if (rw_opt_no_bidir_iter) {
+ rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+ }
+ else {
+ run_tests (dummy, BidirIter<T>(), (T*)0, pred);
+ }
+
+ if (rw_opt_no_rnd_iter) {
+ rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+ }
+ else {
+ run_tests (dummy, RandomAccessIter<T>(), (T*)0, pred);
+ }
+}
+
+/**************************************************************************/
+
+static void
+run_test (bool test_predicate)
+{
+ rw_info (0, 0, 0,
+ "template <class %s, class %s> "
+ "%1$s std::find_first_of (%1$s, %1$s, %2$s, %2$s%{?}, %s%{;})",
+ "ForwardIterator1", "ForwardIterator2",
+ 0 != test_predicate, "Predicate");
+
+ const EqualityPredicate<X, X>* const pred = test_predicate ?
+ (EqualityPredicate<X, X>*)1 : (EqualityPredicate<X, X>*)0;
+
+ if (rw_opt_no_fwd_iter) {
+ rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
+ }
+ else {
+ run_test (FwdIter<X>(), (X*)0, pred);
+ }
+
+ if (rw_opt_no_bidir_iter) {
+ rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
+ }
+ else {
+ run_test (BidirIter<X>(), (X*)0, pred);
+ }
+
+ if (rw_opt_no_rnd_iter) {
+ rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
+ }
+ else {
+ run_test (RandomAccessIter<X>(), (X*)0, pred);
+ }
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char*[])
+{
+ run_test (false);
+
+ if (rw_opt_no_predicate) {
+ rw_note (0, __FILE__, __LINE__, "Predicate test disabled");
+ }
+ else {
+ run_test (true);
+ }
+
+ return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+ return rw_test (argc, argv, __FILE__,
+ "lib.alg.find.first.of",
+ 0 /* no comment */, run_test,
+ "|-no-ForwardIterator#"
+ "|-no-BidirectionalIterator#"
+ "|-no-RandomAccessIterator#"
+ "|-no-Predicate#",
+ &rw_opt_no_fwd_iter,
+ &rw_opt_no_bidir_iter,
+ &rw_opt_no_rnd_iter,
+ &rw_opt_no_predicate);
+}
Propchange: incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/algorithms/25.find.first.cpp
------------------------------------------------------------------------------
svn:keywords = Id