20.operators.cpp

Go to the documentation of this file.

 
// 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 <cstddef>  // for std::size_t
 
#include <rw_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() (T) 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;
 
#if !defined _RWSTD_NO_DEBUG_ITER
    RandomNumberGenerator<typename I::difference_type> rndgen;
#else
    RandomNumberGenerator<T> rndgen;
#endif
 
    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 */);
}