libs/dynamic_bitset/dyn_bitset_unit_tests2.cpp

   1 // -----------------------------------------------------------
   2 //              Copyright (c) 2001 Jeremy Siek
   3 //           Copyright (c) 2003-2006 Gennaro Prota
   4 //
   5 // Distributed under the Boost Software License, Version 1.0.
   6 //    (See accompanying file LICENSE_1_0.txt or copy at
   7 //          http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // -----------------------------------------------------------
  10
  11 #include "bitset_test.hpp"
  12 #include "boost/dynamic_bitset/dynamic_bitset.hpp"
  13 #include "boost/config.hpp"
  14
  15
  16 template <typename Block>
  17 void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
  18 {
  19   typedef boost::dynamic_bitset<Block> bitset_type;
  20   typedef bitset_test< bitset_type > Tests;
  21   const int bits_per_block = bitset_type::bits_per_block;
  22
  23   std::string long_string = get_long_string();
  24
  25   //=====================================================================
  26   // Test operator&=
  27   {
  28     boost::dynamic_bitset<Block> lhs, rhs;
  29     Tests::and_assignment(lhs, rhs);
  30   }
  31   {
  32     boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
  33     Tests::and_assignment(lhs, rhs);
  34   }
  35   {
  36     boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
  37     Tests::and_assignment(lhs, rhs);
  38   }
  39   {
  40     boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
  41     Tests::and_assignment(lhs, rhs);
  42   }
  43   //=====================================================================
  44   // Test operator |=
  45   {
  46     boost::dynamic_bitset<Block> lhs, rhs;
  47     Tests::or_assignment(lhs, rhs);
  48   }
  49   {
  50     boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
  51     Tests::or_assignment(lhs, rhs);
  52   }
  53   {
  54     boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
  55     Tests::or_assignment(lhs, rhs);
  56   }
  57   {
  58     boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
  59     Tests::or_assignment(lhs, rhs);
  60   }
  61   //=====================================================================
  62   // Test operator^=
  63   {
  64     boost::dynamic_bitset<Block> lhs, rhs;
  65     Tests::xor_assignment(lhs, rhs);
  66   }
  67   {
  68     boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
  69     Tests::xor_assignment(lhs, rhs);
  70   }
  71   {
  72     boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
  73     Tests::xor_assignment(lhs, rhs);
  74   }
  75   {
  76     boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
  77     Tests::xor_assignment(lhs, rhs);
  78   }
  79   //=====================================================================
  80   // Test operator-=
  81   {
  82     boost::dynamic_bitset<Block> lhs, rhs;
  83     Tests::sub_assignment(lhs, rhs);
  84   }
  85   {
  86     boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
  87     Tests::sub_assignment(lhs, rhs);
  88   }
  89   {
  90     boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
  91     Tests::sub_assignment(lhs, rhs);
  92   }
  93   {
  94     boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
  95     Tests::sub_assignment(lhs, rhs);
  96   }
  97   //=====================================================================
  98   // Test operator<<=
  99   { // case pos == 0
 100     std::size_t pos = 0;
 101     {
 102       boost::dynamic_bitset<Block> b;
 103       Tests::shift_left_assignment(b, pos);
 104     }
 105     {
 106       boost::dynamic_bitset<Block> b(std::string("1010"));
 107       Tests::shift_left_assignment(b, pos);
 108     }
 109     {
 110       boost::dynamic_bitset<Block> b(long_string);
 111       Tests::shift_left_assignment(b, pos);
 112     }
 113   }
 114   {
 115     // test with both multiple and
 116     // non multiple of bits_per_block
 117     const int how_many = 10;
 118     for (int i = 1; i <= how_many; ++i) {
 119         std::size_t     multiple = i * bits_per_block;
 120         std::size_t non_multiple = multiple - 1;
 121         boost::dynamic_bitset<Block> b(long_string);
 122
 123         Tests::shift_left_assignment(b, multiple);
 124         Tests::shift_left_assignment(b, non_multiple);
 125     }
 126   }
 127   { // case pos == size()/2
 128     std::size_t pos = long_string.size() / 2;
 129     boost::dynamic_bitset<Block> b(long_string);
 130     Tests::shift_left_assignment(b, pos);
 131   }
 132   { // case pos >= n
 133     std::size_t pos = long_string.size();
 134     boost::dynamic_bitset<Block> b(long_string);
 135     Tests::shift_left_assignment(b, pos);
 136   }
 137   //=====================================================================
 138   // Test operator>>=
 139   { // case pos == 0
 140     std::size_t pos = 0;
 141     {
 142       boost::dynamic_bitset<Block> b;
 143       Tests::shift_right_assignment(b, pos);
 144     }
 145     {
 146       boost::dynamic_bitset<Block> b(std::string("1010"));
 147       Tests::shift_right_assignment(b, pos);
 148     }
 149     {
 150       boost::dynamic_bitset<Block> b(long_string);
 151       Tests::shift_right_assignment(b, pos);
 152     }
 153   }
 154   {
 155     // test with both multiple and
 156     // non multiple of bits_per_block
 157     const int how_many = 10;
 158     for (int i = 1; i <= how_many; ++i) {
 159         std::size_t     multiple = i * bits_per_block;
 160         std::size_t non_multiple = multiple - 1;
 161         boost::dynamic_bitset<Block> b(long_string);
 162
 163         Tests::shift_right_assignment(b, multiple);
 164         Tests::shift_right_assignment(b, non_multiple);
 165     }
 166
 167   }
 168   { // case pos == size()/2
 169     std::size_t pos = long_string.size() / 2;
 170     boost::dynamic_bitset<Block> b(long_string);
 171     Tests::shift_right_assignment(b, pos);
 172   }
 173   { // case pos >= n
 174     std::size_t pos = long_string.size();
 175     boost::dynamic_bitset<Block> b(long_string);
 176     Tests::shift_right_assignment(b, pos);
 177   }
 178   //=====================================================================
 179   // test b.set()
 180   {
 181     boost::dynamic_bitset<Block> b;
 182     Tests::set_all(b);
 183   }
 184   {
 185     boost::dynamic_bitset<Block> b(std::string("0"));
 186     Tests::set_all(b);
 187   }
 188   {
 189     boost::dynamic_bitset<Block> b(long_string);
 190     Tests::set_all(b);
 191   }
 192   //=====================================================================
 193   // Test b.set(pos)
 194   { // case pos >= b.size()
 195     boost::dynamic_bitset<Block> b;
 196     Tests::set_one(b, 0, true);
 197   }
 198   { // case pos < b.size()
 199     boost::dynamic_bitset<Block> b(std::string("0"));
 200     Tests::set_one(b, 0, true);
 201   }
 202   { // case pos == b.size() / 2
 203     boost::dynamic_bitset<Block> b(long_string);
 204     Tests::set_one(b, long_string.size()/2, true);
 205   }
 206   //=====================================================================
 207   // Test b.reset()
 208   {
 209     boost::dynamic_bitset<Block> b;
 210     Tests::reset_all(b);
 211   }
 212   {
 213     boost::dynamic_bitset<Block> b(std::string("0"));
 214     Tests::reset_all(b);
 215   }
 216   {
 217     boost::dynamic_bitset<Block> b(long_string);
 218     Tests::reset_all(b);
 219   }
 220   //=====================================================================
 221   // Test b.reset(pos)
 222   { // case pos >= b.size()
 223     boost::dynamic_bitset<Block> b;
 224     Tests::reset_one(b, 0);
 225   }
 226   { // case pos < b.size()
 227     boost::dynamic_bitset<Block> b(std::string("0"));
 228     Tests::reset_one(b, 0);
 229   }
 230   { // case pos == b.size() / 2
 231     boost::dynamic_bitset<Block> b(long_string);
 232     Tests::reset_one(b, long_string.size()/2);
 233   }
 234   //=====================================================================
 235   // Test ~b
 236   {
 237     boost::dynamic_bitset<Block> b;
 238     Tests::operator_flip(b);
 239   }
 240   {
 241     boost::dynamic_bitset<Block> b(std::string("1"));
 242     Tests::operator_flip(b);
 243   }
 244   {
 245     boost::dynamic_bitset<Block> b(long_string);
 246     Tests::operator_flip(b);
 247   }
 248   //=====================================================================
 249   // Test b.flip()
 250   {
 251     boost::dynamic_bitset<Block> b;
 252     Tests::flip_all(b);
 253   }
 254   {
 255     boost::dynamic_bitset<Block> b(std::string("1"));
 256     Tests::flip_all(b);
 257   }
 258   {
 259     boost::dynamic_bitset<Block> b(long_string);
 260     Tests::flip_all(b);
 261   }
 262   //=====================================================================
 263   // Test b.flip(pos)
 264   { // case pos >= b.size()
 265     boost::dynamic_bitset<Block> b;
 266     Tests::flip_one(b, 0);
 267   }
 268   { // case pos < b.size()
 269     boost::dynamic_bitset<Block> b(std::string("0"));
 270     Tests::flip_one(b, 0);
 271   }
 272   { // case pos == b.size() / 2
 273     boost::dynamic_bitset<Block> b(long_string);
 274     Tests::flip_one(b, long_string.size()/2);
 275   }
 276 }
 277
 278 int
 279 test_main(int, char*[])
 280 {
 281   run_test_cases<unsigned char>();
 282   run_test_cases<unsigned short>();
 283   run_test_cases<unsigned int>();
 284   run_test_cases<unsigned long>();
 285 # ifdef BOOST_HAS_LONG_LONG
 286   run_test_cases< ::boost::ulong_long_type>();
 287 # endif
 288
 289   return 0;
 290 }