ceph/src/boost/libs/utility/iterators_test.cpp

   1 //  Demonstrate and test boost/operators.hpp on std::iterators  --------------//
   2
   3 //  (C) Copyright Jeremy Siek 1999.
   4 // Distributed under the Boost Software License, Version 1.0. (See
   5 // accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7
   8 //  See http://www.boost.org for most recent version including documentation.
   9
  10 //  Revision History
  11 //  29 May 01 Factored implementation, added comparison tests, use Test Tools
  12 //            library (Daryle Walker)
  13 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
  14
  15 #define  BOOST_INCLUDE_MAIN
  16 #include <boost/test/test_tools.hpp>  // for main
  17
  18 #include <boost/config.hpp>     // for BOOST_STATIC_CONSTANT
  19 #include <boost/cstdlib.hpp>    // for boost::exit_success
  20 #include <boost/operators.hpp>  // for boost::random_access_iterator_helper
  21
  22 #include <cstddef>    // for std::ptrdiff_t, std::size_t
  23 #include <cstring>    // for std::strcmp
  24 #include <iostream>   // for std::cout (std::endl, ends, and flush indirectly)
  25 #include <string>     // for std::string
  26 #include <sstream>    // for std::stringstream
  27
  28 # ifdef BOOST_NO_STDC_NAMESPACE
  29     namespace std { using ::strcmp; }
  30 # endif
  31
  32
  33 // Iterator test class
  34 template <class T, class R, class P>
  35 struct test_iter
  36   : public boost::random_access_iterator_helper<
  37      test_iter<T,R,P>, T, std::ptrdiff_t, P, R>
  38 {
  39   typedef test_iter self;
  40   typedef R Reference;
  41   typedef std::ptrdiff_t Distance;
  42
  43 public:
  44   explicit test_iter(T* i =0) : _i(i) { }
  45   test_iter(const self& x) : _i(x._i) { }
  46   self& operator=(const self& x) { _i = x._i; return *this; }
  47   Reference operator*() const { return *_i; }
  48   self& operator++() { ++_i; return *this; }
  49   self& operator--() { --_i; return *this; }
  50   self& operator+=(Distance n) { _i += n; return *this; }
  51   self& operator-=(Distance n) { _i -= n; return *this; }
  52   bool operator==(const self& x) const { return _i == x._i; }
  53   bool operator<(const self& x) const { return _i < x._i; }
  54   friend Distance operator-(const self& x, const self& y) {
  55     return x._i - y._i;
  56   }
  57 protected:
  58   P _i;
  59 };
  60
  61 // Iterator operator testing classes
  62 class test_opr_base
  63 {
  64 protected:
  65     // Test data and types
  66     BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
  67
  68     typedef std::string  fruit_array_type[ fruit_length ];
  69
  70     static  fruit_array_type    fruit;
  71
  72 };  // test_opr_base
  73
  74 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
  75 //  A definition is required even for integral static constants
  76 const std::size_t test_opr_base::fruit_length;
  77 #endif
  78
  79 template <typename T, typename R = T&, typename P = T*>
  80 class test_opr
  81     : public test_opr_base
  82 {
  83     typedef test_opr<T, R, P>  self_type;
  84
  85 public:
  86     // Types
  87     typedef T  value_type;
  88     typedef R  reference;
  89     typedef P  pointer;
  90
  91     typedef test_iter<T, R, P>  iter_type;
  92
  93     // Test controller
  94     static  void  master_test( char const name[] );
  95
  96 private:
  97     // Test data
  98     static iter_type const  fruit_begin;
  99     static iter_type const  fruit_end;
 100
 101     // Test parts
 102     static  void  post_increment_test();
 103     static  void  post_decrement_test();
 104     static  void  indirect_referral_test();
 105     static  void  offset_addition_test();
 106     static  void  reverse_offset_addition_test();
 107     static  void  offset_subtraction_test();
 108     static  void  comparison_test();
 109     static  void  indexing_test();
 110
 111 };  // test_opr
 112
 113
 114 // Class-static data definitions
 115 test_opr_base::fruit_array_type
 116  test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };
 117
 118 template <typename T, typename R, typename P>
 119   typename test_opr<T, R, P>::iter_type const
 120  test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit );
 121
 122 template <typename T, typename R, typename P>
 123 typename test_opr<T, R, P>::iter_type const
 124  test_opr<T, R, P>::fruit_end = test_iter<T,R,P>( fruit + fruit_length );
 125
 126
 127 // Main testing function
 128 int
 129 test_main( int , char * [] )
 130 {
 131     using std::string;
 132
 133     typedef test_opr<string, string &, string *>              test1_type;
 134     typedef test_opr<string, string const &, string const *>  test2_type;
 135
 136     test1_type::master_test( "non-const string" );
 137     test2_type::master_test( "const string" );
 138
 139     return boost::exit_success;
 140 }
 141
 142 // Tests for all of the operators added by random_access_iterator_helper
 143 template <typename T, typename R, typename P>
 144 void
 145 test_opr<T, R, P>::master_test
 146 (
 147     char const  name[]
 148 )
 149 {
 150     std::cout << "Doing test run for " << name << '.' << std::endl;
 151
 152     post_increment_test();
 153     post_decrement_test();
 154     indirect_referral_test();
 155     offset_addition_test();
 156     reverse_offset_addition_test();
 157     offset_subtraction_test();
 158     comparison_test();
 159     indexing_test();
 160 }
 161
 162 // Test post-increment
 163 template <typename T, typename R, typename P>
 164 void
 165 test_opr<T, R, P>::post_increment_test
 166 (
 167 )
 168 {
 169     std::cout << "\tDoing post-increment test." << std::endl;
 170
 171     std::stringstream oss;
 172     for ( iter_type i = fruit_begin ; i != fruit_end ; )
 173     {
 174         oss << *i++ << ' ';
 175     }
 176
 177     BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 178 }
 179
 180 // Test post-decrement
 181 template <typename T, typename R, typename P>
 182 void
 183 test_opr<T, R, P>::post_decrement_test
 184 (
 185 )
 186 {
 187     std::cout << "\tDoing post-decrement test." << std::endl;
 188
 189     std::stringstream oss;
 190     for ( iter_type i = fruit_end ; i != fruit_begin ; )
 191     {
 192         i--;
 193         oss << *i << ' ';
 194     }
 195
 196     BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
 197 }
 198
 199 // Test indirect structure referral
 200 template <typename T, typename R, typename P>
 201 void
 202 test_opr<T, R, P>::indirect_referral_test
 203 (
 204 )
 205 {
 206     std::cout << "\tDoing indirect reference test." << std::endl;
 207
 208     std::stringstream oss;
 209     for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
 210     {
 211         oss << i->size() << ' ';
 212     }
 213
 214     BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
 215 }
 216
 217 // Test offset addition
 218 template <typename T, typename R, typename P>
 219 void
 220 test_opr<T, R, P>::offset_addition_test
 221 (
 222 )
 223 {
 224     std::cout << "\tDoing offset addition test." << std::endl;
 225
 226     std::ptrdiff_t const  two = 2;
 227     std::stringstream oss;
 228     for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
 229     {
 230         oss << *i << ' ';
 231     }
 232
 233     BOOST_CHECK( oss.str() == "apple pear grape ");
 234 }
 235
 236 // Test offset addition, in reverse order
 237 template <typename T, typename R, typename P>
 238 void
 239 test_opr<T, R, P>::reverse_offset_addition_test
 240 (
 241 )
 242 {
 243     std::cout << "\tDoing reverse offset addition test." << std::endl;
 244
 245     std::ptrdiff_t const  two = 2;
 246     std::stringstream oss;
 247     for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
 248     {
 249         oss << *i << ' ';
 250     }
 251
 252     BOOST_CHECK( oss.str() == "apple pear grape ");
 253 }
 254
 255 // Test offset subtraction
 256 template <typename T, typename R, typename P>
 257 void
 258 test_opr<T, R, P>::offset_subtraction_test
 259 (
 260 )
 261 {
 262     std::cout << "\tDoing offset subtraction test." << std::endl;
 263
 264     std::ptrdiff_t const  two = 2;
 265     std::stringstream oss;
 266     for ( iter_type i = fruit_end ; fruit_begin < i ; )
 267     {
 268         i = i - two;
 269         if ( (fruit_begin < i) || (fruit_begin == i) )
 270         {
 271             oss << *i << ' ';
 272         }
 273     }
 274
 275     BOOST_CHECK( oss.str() == "grape pear apple ");
 276 }
 277
 278 // Test comparisons
 279 template <typename T, typename R, typename P>
 280 void
 281 test_opr<T, R, P>::comparison_test
 282 (
 283 )
 284 {
 285     using std::cout;
 286     using std::ptrdiff_t;
 287
 288     cout << "\tDoing comparison tests.\n\t\tPass:";
 289
 290     for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
 291     {
 292         ptrdiff_t const  i_offset = i - fruit_begin;
 293
 294         cout << ' ' << *i << std::flush;
 295         for ( iter_type j = fruit_begin ; j != fruit_end ; ++j )
 296         {
 297             ptrdiff_t const  j_offset = j - fruit_begin;
 298
 299             BOOST_CHECK( (i != j) == (i_offset != j_offset) );
 300             BOOST_CHECK( (i > j) == (i_offset > j_offset) );
 301             BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
 302             BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
 303         }
 304     }
 305     cout << std::endl;
 306 }
 307
 308 // Test indexing
 309 template <typename T, typename R, typename P>
 310 void
 311 test_opr<T, R, P>::indexing_test
 312 (
 313 )
 314 {
 315     std::cout << "\tDoing indexing test." << std::endl;
 316
 317     std::stringstream oss;
 318     for ( std::size_t k = 0u ; k < fruit_length ; ++k )
 319     {
 320         oss << fruit_begin[ k ] << ' ';
 321     }
 322
 323     BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 324 }