stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r369586 - /incubator/stdcxx/trunk/tests/utilities/20.operators.cpp
Date Mon, 16 Jan 2006 22:23:48 GMT
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  <sebor@roguewave.com>

	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



Mime
View raw message