ceph/src/boost/libs/lambda/test/switch_construct.cpp

   1 //  switch_test.cpp  -- The Boost Lambda Library --------------------------
   2 //
   3 // Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
   4 // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
   5 //
   6 // Distributed under the Boost Software License, Version 1.0. (See
   7 // accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10 // For more information, see www.boost.org
  11
  12 // -----------------------------------------------------------------------
  13
  14
  15 #include <boost/core/lightweight_test.hpp>
  16 #define BOOST_CHECK BOOST_TEST
  17
  18
  19 #include "boost/lambda/lambda.hpp"
  20 #include "boost/lambda/if.hpp"
  21 #include "boost/lambda/switch.hpp"
  22
  23 #include <iostream>
  24 #include <algorithm>
  25 #include <vector>
  26 #include <string>
  27
  28
  29
  30 // Check that elements 0 -- index are 1, and the rest are 0
  31 bool check(const std::vector<int>& v, int index) {
  32   using namespace boost::lambda;
  33   int counter = 0;
  34   std::vector<int>::const_iterator
  35     result = std::find_if(v.begin(), v.end(),
  36                      ! if_then_else_return(
  37                          var(counter)++ <= index,
  38                          _1 == 1,
  39                          _1 == 0)
  40                     );
  41   return result == v.end();
  42 }
  43
  44
  45
  46 void do_switch_no_defaults_tests() {
  47
  48   using namespace boost::lambda;
  49
  50   int i = 0;
  51   std::vector<int> v,w;
  52
  53   // elements from 0 to 9
  54   std::generate_n(std::back_inserter(v),
  55                   10,
  56                   var(i)++);
  57   std::fill_n(std::back_inserter(w), 10, 0);
  58
  59   // ---
  60   std::for_each(v.begin(), v.end(),
  61     switch_statement(
  62       _1,
  63       case_statement<0>(++var(w[0]))
  64     )
  65   );
  66
  67   BOOST_CHECK(check(w, 0));
  68   std::fill_n(w.begin(), 10, 0);
  69
  70   // ---
  71   std::for_each(v.begin(), v.end(),
  72     switch_statement(
  73       _1,
  74       case_statement<0>(++var(w[0])),
  75       case_statement<1>(++var(w[1]))
  76     )
  77   );
  78
  79   BOOST_CHECK(check(w, 1));
  80   std::fill_n(w.begin(), 10, 0);
  81
  82   // ---
  83   std::for_each(v.begin(), v.end(),
  84     switch_statement(
  85       _1,
  86       case_statement<0>(++var(w[0])),
  87       case_statement<1>(++var(w[1])),
  88       case_statement<2>(++var(w[2]))
  89      )
  90   );
  91
  92   BOOST_CHECK(check(w, 2));
  93   std::fill_n(w.begin(), 10, 0);
  94
  95   // ---
  96   std::for_each(v.begin(), v.end(),
  97     switch_statement(
  98       _1,
  99       case_statement<0>(++var(w[0])),
 100       case_statement<1>(++var(w[1])),
 101       case_statement<2>(++var(w[2])),
 102       case_statement<3>(++var(w[3]))
 103     )
 104   );
 105
 106   BOOST_CHECK(check(w, 3));
 107   std::fill_n(w.begin(), 10, 0);
 108
 109   // ---
 110   std::for_each(v.begin(), v.end(),
 111     switch_statement(
 112       _1,
 113       case_statement<0>(++var(w[0])),
 114       case_statement<1>(++var(w[1])),
 115       case_statement<2>(++var(w[2])),
 116       case_statement<3>(++var(w[3])),
 117       case_statement<4>(++var(w[4]))
 118     )
 119   );
 120
 121   BOOST_CHECK(check(w, 4));
 122   std::fill_n(w.begin(), 10, 0);
 123
 124   // ---
 125   std::for_each(v.begin(), v.end(),
 126     switch_statement(
 127       _1,
 128       case_statement<0>(++var(w[0])),
 129       case_statement<1>(++var(w[1])),
 130       case_statement<2>(++var(w[2])),
 131       case_statement<3>(++var(w[3])),
 132       case_statement<4>(++var(w[4])),
 133       case_statement<5>(++var(w[5]))
 134     )
 135   );
 136
 137   BOOST_CHECK(check(w, 5));
 138   std::fill_n(w.begin(), 10, 0);
 139
 140   // ---
 141   std::for_each(v.begin(), v.end(),
 142     switch_statement(
 143       _1,
 144       case_statement<0>(++var(w[0])),
 145       case_statement<1>(++var(w[1])),
 146       case_statement<2>(++var(w[2])),
 147       case_statement<3>(++var(w[3])),
 148       case_statement<4>(++var(w[4])),
 149       case_statement<5>(++var(w[5])),
 150       case_statement<6>(++var(w[6]))
 151     )
 152   );
 153
 154   BOOST_CHECK(check(w, 6));
 155   std::fill_n(w.begin(), 10, 0);
 156
 157   // ---
 158   std::for_each(v.begin(), v.end(),
 159     switch_statement(
 160       _1,
 161       case_statement<0>(++var(w[0])),
 162       case_statement<1>(++var(w[1])),
 163       case_statement<2>(++var(w[2])),
 164       case_statement<3>(++var(w[3])),
 165       case_statement<4>(++var(w[4])),
 166       case_statement<5>(++var(w[5])),
 167       case_statement<6>(++var(w[6])),
 168       case_statement<7>(++var(w[7]))
 169     )
 170   );
 171
 172   BOOST_CHECK(check(w, 7));
 173   std::fill_n(w.begin(), 10, 0);
 174
 175   // ---
 176   std::for_each(v.begin(), v.end(),
 177     switch_statement(
 178       _1,
 179       case_statement<0>(++var(w[0])),
 180       case_statement<1>(++var(w[1])),
 181       case_statement<2>(++var(w[2])),
 182       case_statement<3>(++var(w[3])),
 183       case_statement<4>(++var(w[4])),
 184       case_statement<5>(++var(w[5])),
 185       case_statement<6>(++var(w[6])),
 186       case_statement<7>(++var(w[7])),
 187       case_statement<8>(++var(w[8]))
 188     )
 189   );
 190
 191   BOOST_CHECK(check(w, 8));
 192   std::fill_n(w.begin(), 10, 0);
 193
 194 }
 195
 196
 197 void do_switch_yes_defaults_tests() {
 198
 199   using namespace boost::lambda;
 200
 201   int i = 0;
 202   std::vector<int> v,w;
 203
 204   // elements from 0 to 9
 205   std::generate_n(std::back_inserter(v),
 206                   10,
 207                   var(i)++);
 208   std::fill_n(std::back_inserter(w), 10, 0);
 209
 210   int default_count;
 211   // ---
 212   default_count = 0;
 213   std::for_each(v.begin(), v.end(),
 214     switch_statement(
 215       _1,
 216       default_statement(++var(default_count))
 217     )
 218   );
 219
 220   BOOST_CHECK(check(w, -1));
 221   BOOST_CHECK(default_count == 10);
 222   std::fill_n(w.begin(), 10, 0);
 223
 224   // ---
 225   default_count = 0;
 226   std::for_each(v.begin(), v.end(),
 227     switch_statement(
 228       _1,
 229       case_statement<0>(++var(w[0])),
 230       default_statement(++var(default_count))
 231     )
 232   );
 233
 234   BOOST_CHECK(check(w, 0));
 235   BOOST_CHECK(default_count == 9);
 236   std::fill_n(w.begin(), 10, 0);
 237
 238   // ---
 239   default_count = 0;
 240   std::for_each(v.begin(), v.end(),
 241     switch_statement(
 242       _1,
 243       case_statement<0>(++var(w[0])),
 244       case_statement<1>(++var(w[1])),
 245       default_statement(++var(default_count))
 246      )
 247   );
 248
 249   BOOST_CHECK(check(w, 1));
 250   BOOST_CHECK(default_count == 8);
 251   std::fill_n(w.begin(), 10, 0);
 252
 253   // ---
 254   default_count = 0;
 255   std::for_each(v.begin(), v.end(),
 256     switch_statement(
 257       _1,
 258       case_statement<0>(++var(w[0])),
 259       case_statement<1>(++var(w[1])),
 260       case_statement<2>(++var(w[2])),
 261       default_statement(++var(default_count))
 262     )
 263   );
 264
 265   BOOST_CHECK(check(w, 2));
 266   BOOST_CHECK(default_count == 7);
 267   std::fill_n(w.begin(), 10, 0);
 268
 269   // ---
 270   default_count = 0;
 271   std::for_each(v.begin(), v.end(),
 272     switch_statement(
 273       _1,
 274       case_statement<0>(++var(w[0])),
 275       case_statement<1>(++var(w[1])),
 276       case_statement<2>(++var(w[2])),
 277       case_statement<3>(++var(w[3])),
 278       default_statement(++var(default_count))
 279     )
 280   );
 281
 282   BOOST_CHECK(check(w, 3));
 283   BOOST_CHECK(default_count == 6);
 284   std::fill_n(w.begin(), 10, 0);
 285
 286   // ---
 287   default_count = 0;
 288   std::for_each(v.begin(), v.end(),
 289     switch_statement(
 290       _1,
 291       case_statement<0>(++var(w[0])),
 292       case_statement<1>(++var(w[1])),
 293       case_statement<2>(++var(w[2])),
 294       case_statement<3>(++var(w[3])),
 295       case_statement<4>(++var(w[4])),
 296       default_statement(++var(default_count))
 297     )
 298   );
 299
 300   BOOST_CHECK(check(w, 4));
 301   BOOST_CHECK(default_count == 5);
 302   std::fill_n(w.begin(), 10, 0);
 303
 304   // ---
 305   default_count = 0;
 306   std::for_each(v.begin(), v.end(),
 307     switch_statement(
 308       _1,
 309       case_statement<0>(++var(w[0])),
 310       case_statement<1>(++var(w[1])),
 311       case_statement<2>(++var(w[2])),
 312       case_statement<3>(++var(w[3])),
 313       case_statement<4>(++var(w[4])),
 314       case_statement<5>(++var(w[5])),
 315       default_statement(++var(default_count))
 316     )
 317   );
 318
 319   BOOST_CHECK(check(w, 5));
 320   BOOST_CHECK(default_count == 4);
 321   std::fill_n(w.begin(), 10, 0);
 322
 323   // ---
 324   default_count = 0;
 325   std::for_each(v.begin(), v.end(),
 326     switch_statement(
 327       _1,
 328       case_statement<0>(++var(w[0])),
 329       case_statement<1>(++var(w[1])),
 330       case_statement<2>(++var(w[2])),
 331       case_statement<3>(++var(w[3])),
 332       case_statement<4>(++var(w[4])),
 333       case_statement<5>(++var(w[5])),
 334       case_statement<6>(++var(w[6])),
 335       default_statement(++var(default_count))
 336     )
 337   );
 338
 339   BOOST_CHECK(check(w, 6));
 340   BOOST_CHECK(default_count == 3);
 341   std::fill_n(w.begin(), 10, 0);
 342
 343   // ---
 344   default_count = 0;
 345   std::for_each(v.begin(), v.end(),
 346     switch_statement(
 347       _1,
 348       case_statement<0>(++var(w[0])),
 349       case_statement<1>(++var(w[1])),
 350       case_statement<2>(++var(w[2])),
 351       case_statement<3>(++var(w[3])),
 352       case_statement<4>(++var(w[4])),
 353       case_statement<5>(++var(w[5])),
 354       case_statement<6>(++var(w[6])),
 355       case_statement<7>(++var(w[7])),
 356       default_statement(++var(default_count))
 357     )
 358   );
 359
 360   BOOST_CHECK(check(w, 7));
 361   BOOST_CHECK(default_count == 2);
 362   std::fill_n(w.begin(), 10, 0);
 363
 364 }
 365
 366 void test_empty_cases() {
 367
 368   using namespace boost::lambda;
 369
 370   // ---
 371   switch_statement(
 372       _1,
 373       default_statement()
 374   )(make_const(1));
 375
 376   switch_statement(
 377       _1,
 378       case_statement<1>()
 379   )(make_const(1));
 380
 381 }
 382
 383 int main() {
 384
 385   do_switch_no_defaults_tests();
 386   do_switch_yes_defaults_tests();
 387
 388   test_empty_cases();
 389
 390   return boost::report_errors();
 391
 392 }