EIC code displayed by LXR master/​include/​boost/​pending/​iterator_tests.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-09-18 08:54:09

 // Copyright David Abrahams and Jeremy Siek 2003.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_ITERATOR_TESTS_HPP
 # define BOOST_ITERATOR_TESTS_HPP
 
 // This is meant to be the beginnings of a comprehensive, generic
 // test suite for STL concepts such as iterators and containers.
 //
 // Revision History:
 // 28 Apr 2002  Fixed input iterator requirements.
 //              For a == b a++ == b++ is no longer required.
 //              See 24.1.1/3 for details.
 //              (Thomas Witt)
 // 08 Feb 2001  Fixed bidirectional iterator test so that
 //              --i is no longer a precondition.
 //              (Jeremy Siek)
 // 04 Feb 2001  Added lvalue test, corrected preconditions
 //              (David Abrahams)
 
 # include <iterator>
 # include <type_traits>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 # include <boost/core/ignore_unused.hpp>
 # include <boost/core/lightweight_test.hpp>
 
 namespace boost {
 
   // use this for the value type
 struct dummyT {
   dummyT() { }
   dummyT(detail::dummy_constructor) { }
   dummyT(int x) : m_x(x) { }
   int foo() const { return m_x; }
   bool operator==(const dummyT& d) const { return m_x == d.m_x; }
   int m_x;
 };
 
 }
 
 namespace boost {
 namespace iterators {
 
 // Tests whether type Iterator satisfies the requirements for a
 // TrivialIterator.
 // Preconditions: i != j, *i == val
 template <class Iterator, class T>
 void trivial_iterator_test(const Iterator i, const Iterator j, T val)
 {
   Iterator k;
   BOOST_TEST(i == i);
   BOOST_TEST(j == j);
   BOOST_TEST(i != j);
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
   T v = *i;
 #else
   typename std::iterator_traits<Iterator>::value_type v = *i;
 #endif
   BOOST_TEST(v == val);
   boost::ignore_unused(v);
 #if 0
   // hmm, this will give a warning for transform_iterator...  perhaps
   // this should be separated out into a stand-alone test since there
   // are several situations where it can't be used, like for
   // integer_range::iterator.
   BOOST_TEST(v == i->foo());
 #endif
   k = i;
   BOOST_TEST(k == k);
   BOOST_TEST(k == i);
   BOOST_TEST(k != j);
   BOOST_TEST(*k == val);
   boost::ignore_unused(k);
 }
 
 
 // Preconditions: i != j
 template <class Iterator, class T>
 void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
 {
   *i = val;
   trivial_iterator_test(i, j, val);
 }
 
 
 // Preconditions: *i == v1, *++i == v2
 template <class Iterator, class T>
 void input_iterator_test(Iterator i, T v1, T v2)
 {
   Iterator i1(i);
 
   BOOST_TEST(i == i1);
   BOOST_TEST(!(i != i1));
 
   // I can see no generic way to create an input iterator
   // that is in the domain of== of i and != i.
   // The following works for istream_iterator but is not
   // guaranteed to work for arbitrary input iterators.
   //
   //   Iterator i2;
   //
   //   BOOST_TEST(i != i2);
   //   BOOST_TEST(!(i == i2));
 
   BOOST_TEST(*i1 == v1);
   BOOST_TEST(*i  == v1);
 
   // we cannot test for equivalence of (void)++i & (void)i++
   // as i is only guaranteed to be single pass.
   BOOST_TEST(*i++ == v1);
   boost::ignore_unused(i1);
 
   i1 = i;
 
   BOOST_TEST(i == i1);
   BOOST_TEST(!(i != i1));
 
   BOOST_TEST(*i1 == v2);
   BOOST_TEST(*i  == v2);
   boost::ignore_unused(i1);
 
   // i is dereferencable, so it must be incrementable.
   ++i;
 
   // how to test for operator-> ?
 }
 
 // how to test output iterator?
 
 
 template <bool is_pointer> struct lvalue_test
 {
     template <class Iterator> static void check(Iterator)
     {
 # ifndef BOOST_NO_STD_ITERATOR_TRAITS
         typedef typename std::iterator_traits<Iterator>::reference reference;
         typedef typename std::iterator_traits<Iterator>::value_type value_type;
 # else
         typedef typename Iterator::reference reference;
         typedef typename Iterator::value_type value_type;
 # endif
         static_assert(std::is_reference<reference>::value, "reference must be a reference type.");
         static_assert(
             std::is_same<reference, value_type&>::value || std::is_same<reference, const value_type&>::value,
             "reference must either be a reference to value_type or constant reference to value_type."
         );
     }
 };
 
 # ifdef BOOST_NO_STD_ITERATOR_TRAITS
 template <> struct lvalue_test<true> {
     template <class T> static void check(T) {}
 };
 #endif
 
 template <class Iterator, class T>
 void forward_iterator_test(Iterator i, T v1, T v2)
 {
   input_iterator_test(i, v1, v2);
 
   Iterator i1 = i, i2 = i;
 
   BOOST_TEST(i == i1++);
   BOOST_TEST(i != ++i2);
 
   trivial_iterator_test(i, i1, v1);
   trivial_iterator_test(i, i2, v1);
 
   ++i;
   BOOST_TEST(i == i1);
   BOOST_TEST(i == i2);
   ++i1;
   ++i2;
 
   trivial_iterator_test(i, i1, v2);
   trivial_iterator_test(i, i2, v2);
 
  // borland doesn't allow non-type template parameters
 # if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
   lvalue_test<std::is_pointer<Iterator>::value>::check(i);
 #endif
 }
 
 // Preconditions: *i == v1, *++i == v2
 template <class Iterator, class T>
 void bidirectional_iterator_test(Iterator i, T v1, T v2)
 {
   forward_iterator_test(i, v1, v2);
   ++i;
 
   Iterator i1 = i, i2 = i;
 
   BOOST_TEST(i == i1--);
   BOOST_TEST(i != --i2);
 
   trivial_iterator_test(i, i1, v2);
   trivial_iterator_test(i, i2, v2);
 
   --i;
   BOOST_TEST(i == i1);
   BOOST_TEST(i == i2);
   ++i1;
   ++i2;
 
   trivial_iterator_test(i, i1, v1);
   trivial_iterator_test(i, i2, v1);
 }
 
 // mutable_bidirectional_iterator_test
 
 template <class U> struct undefined;
 
 // Preconditions: [i,i+N) is a valid range
 template <class Iterator, class TrueVals>
 void random_access_iterator_test(Iterator i, int N, TrueVals vals)
 {
   bidirectional_iterator_test(i, vals[0], vals[1]);
   const Iterator j = i;
   int c;
 
   typedef typename std::iterator_traits<Iterator>::value_type value_type;
   struct local
   {
     static value_type to_value_type(value_type v) { return v; }
   };
 
   for (c = 0; c < N-1; ++c) {
     BOOST_TEST(i == j + c);
     BOOST_TEST(*i == vals[c]);
     BOOST_TEST(*i == local::to_value_type(j[c]));
     BOOST_TEST(*i == *(j + c));
     BOOST_TEST(*i == *(c + j));
     ++i;
     BOOST_TEST(i > j);
     BOOST_TEST(i >= j);
     BOOST_TEST(j <= i);
     BOOST_TEST(j < i);
   }
 
   Iterator k = j + N - 1;
   for (c = 0; c < N-1; ++c) {
     BOOST_TEST(i == k - c);
     BOOST_TEST(*i == vals[N - 1 - c]);
     BOOST_TEST(*i == local::to_value_type(j[N - 1 - c]));
     Iterator q = k - c;
     boost::ignore_unused(q);
     BOOST_TEST(*i == *q);
     BOOST_TEST(i > j);
     BOOST_TEST(i >= j);
     BOOST_TEST(j <= i);
     BOOST_TEST(j < i);
     --i;
   }
 }
 
 // Precondition: i != j
 template <class Iterator, class ConstIterator>
 void const_nonconst_iterator_test(Iterator i, ConstIterator j)
 {
   BOOST_TEST(i != j);
   BOOST_TEST(j != i);
 
   ConstIterator k(i);
   BOOST_TEST(k == i);
   BOOST_TEST(i == k);
 
   k = i;
   BOOST_TEST(k == i);
   BOOST_TEST(i == k);
   boost::ignore_unused(k);
 }
 
 } // namespace iterators
 
 using iterators::undefined;
 using iterators::trivial_iterator_test;
 using iterators::mutable_trivial_iterator_test;
 using iterators::input_iterator_test;
 using iterators::lvalue_test;
 using iterators::forward_iterator_test;
 using iterators::bidirectional_iterator_test;
 using iterators::random_access_iterator_test;
 using iterators::const_nonconst_iterator_test;
 
 } // namespace boost
 
 #endif // BOOST_ITERATOR_TESTS_HPP

This page was automatically generated by the 2.3.7 LXR engine. The LXR team