Author: sebor
Date: Mon Jan 16 14:23:43 2006
New Revision: 369586
URL: http://svn.apache.org/viewcvs?rev=369586&view=rev
Log:
2006-01-16 Martin Sebor <[EMAIL PROTECTED]>
STDCXX-4
* 20.operators.cpp: New test exercising lib.operators, including
STDCXX-120.
Added:
incubator/stdcxx/trunk/tests/utilities/20.operators.cpp (with props)
Added: incubator/stdcxx/trunk/tests/utilities/20.operators.cpp
URL:
http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/utilities/20.operators.cpp?rev=369586&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/utilities/20.operators.cpp (added)
+++ incubator/stdcxx/trunk/tests/utilities/20.operators.cpp Mon Jan 16 14:23:43
2006
@@ -0,0 +1,517 @@
+/***************************************************************************
+ *
+ * 20.operators.cpp - test exercising [lib.operators]
+ *
+ * $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.
+ *
+ **************************************************************************/
+
+// The test exercises the ability to specialize various components of
+// the library (algorithms and containers in particular) on user-defined
+// iterator types in the presence of using directives.
+
+#include <rw/_config.h>
+
+#if defined (__IBMCPP__) && !defined (_RWSTD_NO_IMPLICIT_INCLUSION)
+// Disable implicit inclusion to work around
+// a limitation in IBM's VisualAge 5.0.2.0 (see PR#26959)
+
+# define _RWSTD_NO_IMPLICIT_INCLUSION
+#endif
+
+#if 0 // def _MSC_VER
+// disabled (warnings may be meaningful)
+# pragma warning (disable: 4800)
+# pragma warning (disable: 4805)
+#endif // _MSC_VER
+
+
+#include <algorithm>
+#include <deque>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+
+#include <driver.h>
+
+/**************************************************************************/
+
+_USING (namespace std);
+_USING (namespace std::rel_ops);
+
+
+#ifndef _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+// explicitly instantiate containers
+template class
+std::deque<int, std::allocator<int> >;
+
+template class
+std::list<int,std::allocator<int> >;
+
+template class
+std::map<int, int, std::less<int>, std::allocator<std::pair<const int, int> >
>;
+
+template class
+std::set<int>;
+
+template class
+std::basic_string<int, std::char_traits<int>, std::allocator<int> >;
+
+template class
+std::vector<int, std::allocator<int> >;
+
+#endif // _RWSTD_NO_EXPLICIT_INSTANTIATION
+
+/**************************************************************************/
+
+#if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
+# define FUN(ignore, result, name, arg_list) do { \
+ result (*pf) arg_list = &name; \
+ _RWSTD_UNUSED (pf); \
+ } while (0)
+#else
+ // working around a SunPro 5.3 bug (see PR #25972) that prevents it
+ // from taking the address of a function template in template code
+# define FUN(T, result, name, arg_list) do { \
+ typedef typename T::iterator Iterator; \
+ typedef typename T::const_iterator ConstIterator; \
+ const Iterator *pi = 0; \
+ const ConstIterator *pci = 0; \
+ name (pi, pi); \
+ name (pci, pci); \
+ } while (0)
+#endif // SunPro 5.3
+
+
+#define TEST_INEQUALITY(T) \
+ FUN (T, bool, std::rel_ops::operator!=, \
+ (const T::iterator&, const T::iterator&)); \
+ FUN (T, bool, std::rel_ops::operator!=, \
+ (const T::const_iterator&, const T::const_iterator&))
+
+#define TEST_OPERATORS(T) \
+ TEST_INEQUALITY (T); \
+ FUN (T, bool, std::rel_ops::operator>, \
+ (const T::iterator&, const T::iterator&)); \
+ FUN (T, bool, std::rel_ops::operator<=, \
+ (const T::iterator&, const T::iterator&)); \
+ FUN (T, bool, std::rel_ops::operator>=, \
+ (const T::iterator&, const T::iterator&)); \
+ FUN (T, bool, std::rel_ops::operator>, \
+ (const T::const_iterator&, const T::const_iterator&)); \
+ FUN (T, bool, std::rel_ops::operator<=, \
+ (const T::const_iterator&, const T::const_iterator&)); \
+ FUN (T, bool, std::rel_ops::operator>=, \
+ (const T::const_iterator&, const T::const_iterator&))
+
+
+template <class Container, class RandomAccessIterator>
+void test_iterator (Container, RandomAccessIterator)
+{
+ TEST_OPERATORS (typename Container);
+}
+
+
+template <class Container>
+void test_iterator (Container, int*)
+{
+ // cannot specialize std::rel_ops::operators on native types
+ // or pointers to such things
+}
+
+/**************************************************************************/
+
+template <class T>
+struct UnaryPredicate
+{
+ bool operator() (const T&) const {
+ return true;
+ }
+};
+
+
+template <class T>
+struct BinaryPredicate
+{
+ bool operator() (const T&, const T&) const {
+ return true;
+ }
+};
+
+
+template <class T>
+struct RandomNumberGenerator
+{
+ T operator() (int) const {
+ return T ();
+ }
+};
+
+
+template <class T>
+struct Generator
+{
+ T operator() () const {
+ return T ();
+ }
+};
+
+template <class T>
+struct UnaryFunction
+{
+ T operator() (const T &t) const {
+ return t;
+ }
+};
+
+
+template <class T>
+struct BinaryFunction
+{
+ T operator() (const T &t, const T&) const {
+ return t;
+ }
+};
+
+/**************************************************************************/
+
+template <class T, class InputIterator>
+void test_input_iterators (T, InputIterator)
+{
+ // do not run (compile only), prevent warnings about unreachable code
+ static int count = 0;
+
+ if (++count)
+ return;
+
+ typedef InputIterator I;
+
+ std::for_each (I (), I (), UnaryFunction<T>());
+ std::find (I (), I (), T ());
+ std::find_if (I (), I (), UnaryPredicate<T>());
+
+#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
+ std::count (I (), I (), T ());
+ std::count_if (I (), I (), UnaryPredicate<T>());
+#else // if defined (_RWSTD_NO_CLASS_PARTIAL_SPEC)
+ std::size_t n = 0;
+ std::count (I (), I (), T (), n);
+ std::count_if (I (), I (), UnaryPredicate<T>(), n);
+#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC
+
+ std::mismatch (I (), I (), I ());
+ std::mismatch (I (), I (), I (), BinaryPredicate<T>());
+ std::equal (I (), I (), I ());
+ std::equal (I (), I (), I (), BinaryPredicate<T>());
+
+ std::includes (I (), I (), I (), I ());
+ std::includes (I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::lexicographical_compare (I (), I (), I (), I ());
+ std::lexicographical_compare (I (), I (), I (), I (),
BinaryPredicate<T>());
+}
+
+/**************************************************************************/
+
+template <class T, class OutputIterator>
+void test_output_iterators (T, OutputIterator)
+{
+ // do not run (compile only), prevent warnings about unreachable code
+ static int count = 0;
+
+ if (++count)
+ return;
+
+ typedef OutputIterator I;
+
+ std::copy (I (), I (), I ());
+ std::copy_backward (I (), I (), I ());
+
+ std::transform (I (), I (), I (), UnaryFunction<T>());
+ std::transform (I (), I (), I (), I (), BinaryFunction<T>());
+
+ std::replace_copy (I (), I (), I (), T (), T ());
+ std::replace_copy_if (I (), I (), I (), UnaryPredicate<T>(), T ());
+
+ std::merge (I (), I (), I (), I (), I ());
+ std::merge (I (), I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::set_union (I (), I (), I (), I (), I ());
+ std::set_union (I (), I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::set_intersection (I (), I (), I (), I (), I ());
+ std::set_intersection (I (), I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::set_difference (I (), I (), I (), I (), I ());
+ std::set_difference (I (), I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::set_symmetric_difference (I (), I (), I (), I (), I ());
+ std::set_symmetric_difference (I (), I (), I (), I (), I (),
+ BinaryPredicate<T>());
+
+ std::fill_n (I (), 0, T ());
+
+ std::generate_n (I (), 0, Generator<T>());
+
+ std::remove_copy (I (), I (), I (), T ());
+ std::remove_copy_if (I (), I (), I (), UnaryPredicate<T>());
+
+ std::unique_copy (I (), I (), I ());
+ std::unique_copy (I (), I (), I (), BinaryPredicate<T>());
+
+ std::reverse_copy (I (), I (), I ());
+
+ std::rotate_copy (I (), I (), I (), I ());
+}
+
+/**************************************************************************/
+
+template <class T, class ForwardIterator>
+void test_forward_iterators (T, ForwardIterator)
+{
+ // do not run (compile only), prevent warnings about unreachable code
+ static int count = 0;
+
+ if (++count)
+ return;
+
+ typedef ForwardIterator I;
+
+ std::find_end (I (), I (), I (), I ());
+ std::find_end (I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::find_first_of (I (), I (), I (), I ());
+ std::find_first_of (I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::adjacent_find (I (), I ());
+ std::adjacent_find (I (), I (), BinaryPredicate<T>());
+
+ std::search (I (), I (), I (), I ());
+ std::search (I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::search_n (I (), I (), 0, T ());
+ std::search_n (I (), I (), 0, T (), BinaryPredicate<T>());
+
+ std::swap_ranges (I (), I (), I ());
+ std::iter_swap (I (), I ());
+
+ std::replace (I (), I (), T (), T ());
+ std::replace_if (I (), I (), UnaryPredicate<T>(), T ());
+
+ std::equal_range (I (), I (), T ());
+ std::equal_range (I (), I (), T (), BinaryPredicate<T>());
+
+ std::binary_search (I (), I (), T ());
+ std::binary_search (I (), I (), T (), BinaryPredicate<T>());
+
+ std::min_element (I (), I ());
+ std::min_element (I (), I (), BinaryPredicate<T>());
+
+ std::max_element (I (), I ());
+ std::max_element (I (), I (), BinaryPredicate<T>());
+
+ std::fill (I (), I (), T ());
+
+ std::generate (I (), I (), Generator<T>());
+
+ std::remove (I (), I (), T ());
+ std::remove_if (I (), I (), UnaryPredicate<T>());
+
+ std::unique (I (), I ());
+ std::unique (I (), I (), BinaryPredicate<T>());
+
+ std::reverse (I (), I ());
+
+ std::rotate (I (), I (), I ());
+}
+
+/**************************************************************************/
+
+template <class T, class BidirectionalIterator>
+void test_bidirectional_iterators (T, BidirectionalIterator)
+{
+ // do not run (compile only), prevent warnings about unreachable code
+ static int count = 0;
+
+ if (++count)
+ return;
+
+ typedef BidirectionalIterator I;
+
+ std::partition (I (), I (), UnaryPredicate<T>());
+ std::stable_partition (I (), I (), UnaryPredicate<T>());
+
+ std::lower_bound (I (), I (), T ());
+ std::lower_bound (I (), I (), T (), BinaryPredicate<T>());
+
+ std::upper_bound (I (), I (), T ());
+ std::upper_bound (I (), I (), T (), BinaryPredicate<T>());
+
+ std::inplace_merge (I (), I (), I ());
+ std::inplace_merge (I (), I (), I (), BinaryPredicate<T>());
+
+ std::next_permutation (I (), I ());
+ std::next_permutation (I (), I (), BinaryPredicate<T>());
+
+ std::prev_permutation (I (), I ());
+ std::prev_permutation (I (), I (), BinaryPredicate<T>());
+}
+
+/**************************************************************************/
+
+template <class T, class RandomAccessIterator>
+void test_random_access_iterators (T, RandomAccessIterator)
+{
+ // do not run (compile only), prevent warnings about unreachable code
+ static int count = 0;
+
+ if (++count)
+ return;
+
+ typedef RandomAccessIterator I;
+
+ RandomNumberGenerator<T> rndgen;
+
+ std::random_shuffle (I (), I ());
+ std::random_shuffle (I (), I (), rndgen);
+
+ std::sort (I (), I ());
+ std::sort (I (), I (), BinaryPredicate<T>());
+
+ std::stable_sort (I (), I ());
+ std::stable_sort (I (), I (), BinaryPredicate<T>());
+
+ std::partial_sort (I (), I (), I ());
+ std::partial_sort (I (), I (), I (), BinaryPredicate<T>());
+
+ std::partial_sort_copy (I (), I (), I (), I ());
+ std::partial_sort_copy (I (), I (), I (), I (), BinaryPredicate<T>());
+
+ std::nth_element (I (), I (), I ());
+ std::nth_element (I (), I (), I (), BinaryPredicate<T>());
+
+ std::push_heap (I (), I (), BinaryPredicate<T>());
+ std::pop_heap (I (), I (), BinaryPredicate<T>());
+ std::make_heap (I (), I (), BinaryPredicate<T>());
+ std::sort_heap (I (), I (), BinaryPredicate<T>());
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+ typedef std::map<int, int> Map;
+ typedef std::multimap<int, int> MultiMap;
+
+ // verify that rel_ops operators can be instantiated
+ // on iterators of the containers below
+ TEST_OPERATORS (std::deque<int>);
+
+ TEST_INEQUALITY (std::list<int>);
+ TEST_INEQUALITY (Map);
+ TEST_INEQUALITY (MultiMap);
+ TEST_INEQUALITY (std::set<int>);
+ TEST_INEQUALITY (std::multiset<int>);
+
+#if !defined (_MSC_VER) || _MSC_VER > 1300
+ // prevent from testing with the braindead MSVC 6 and 7
+ // as a workaround for compiler bugs (PR #16828, 22268)
+
+ // prevent attempts to specialize rel_ops operators on
+ // native types (or pointers to such things)
+ test_iterator (std::basic_string<int>(),
+ std::basic_string<int>::iterator ());
+
+ test_iterator (std::vector<int>(),
+ std::vector<int>::iterator ());
+#endif // MSVC > 7.0
+
+ TEST_OPERATORS (std::vector<bool>);
+
+#define TEST_INPUT_ITERATORS(T) \
+ test_input_iterators (T (), std::deque<T>::iterator ()); \
+ test_input_iterators (T (), std::list<T>::iterator ()); \
+ test_input_iterators (std::map<T, T>::value_type (), \
+ std::map<T, T>::iterator ()); \
+ test_input_iterators (std::multimap<T, T>::value_type (), \
+ std::multimap<T, T>::iterator ()); \
+ test_input_iterators (T (), std::set<T>::iterator ()); \
+ test_input_iterators (T (), std::multiset<T, T>::iterator ()); \
+ test_input_iterators (T (), std::basic_string<T>::iterator ()); \
+ test_input_iterators (T (), std::vector<T>::iterator ())
+
+#define TEST_OUTPUT_ITERATORS(T) \
+ test_output_iterators (T (), std::deque<T>::iterator ()); \
+ test_output_iterators (T (), std::list<T>::iterator ()); \
+ test_output_iterators (T (), std::basic_string<T>::iterator ()); \
+ test_output_iterators (T (), std::vector<T>::iterator ())
+
+#define TEST_FORWARD_ITERATORS(T) \
+ test_forward_iterators (T (), std::deque<T>::iterator ()); \
+ test_forward_iterators (T (), std::list<T>::iterator ()); \
+ test_forward_iterators (T (), std::basic_string<T>::iterator ()); \
+ test_forward_iterators (T (), std::vector<T>::iterator ())
+
+#define TEST_BIDIRECTIONAL_ITERATORS(T) \
+ test_bidirectional_iterators (T (), std::deque<T>::iterator ()); \
+ test_bidirectional_iterators (T (), std::list<T>::iterator ()); \
+ test_bidirectional_iterators (T (), std::basic_string<T>::iterator ()); \
+ test_bidirectional_iterators (T (), std::vector<T>::iterator ())
+
+#define TEST_RANDOM_ACCESS_ITERATORS(T) \
+ test_random_access_iterators (T (), std::deque<T>::iterator ()); \
+ test_random_access_iterators (T (), std::basic_string<T>::iterator ()); \
+ test_random_access_iterators (T (), std::vector<T>::iterator ()); \
+
+ // verify that algorithms can be specialized on container
+ // iterators without causing ambiguities with rel_ops
+ TEST_INPUT_ITERATORS (int);
+ TEST_OUTPUT_ITERATORS (int);
+ TEST_FORWARD_ITERATORS (int);
+ TEST_BIDIRECTIONAL_ITERATORS (int);
+ TEST_RANDOM_ACCESS_ITERATORS (int);
+
+#if !defined (__HP_aCC) || _RWSTD_HP_aCC_MINOR > 3600
+
+ // working around an HP aCC bug (PR #28331)
+ TEST_INPUT_ITERATORS (bool);
+ TEST_OUTPUT_ITERATORS (bool);
+ TEST_FORWARD_ITERATORS (bool);
+ TEST_BIDIRECTIONAL_ITERATORS (bool);
+ TEST_RANDOM_ACCESS_ITERATORS (bool);
+
+#endif // HP aCC > x.36
+
+ return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+ return rw_test (argc, argv, __FILE__,
+ "lib.operators",
+ "interactions with the rest of the implementation",
+ run_test,
+ 0 /* no command line options */);
+}
Propchange: incubator/stdcxx/trunk/tests/utilities/20.operators.cpp
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/utilities/20.operators.cpp
------------------------------------------------------------------------------
svn:keywords = Id
