ceph/src/boost/libs/algorithm/test/sort_subrange_test.cpp

   1 #include <boost/config.hpp>
   2 #include <boost/algorithm/sort_subrange.hpp>
   3 #include <boost/algorithm/cxx11/is_sorted.hpp>
   4
   5 #define BOOST_TEST_MAIN
   6 #include <boost/test/unit_test.hpp>
   7
   8 #include <vector>
   9 #include <iostream>
  10 namespace ba = boost::algorithm;
  11
  12 template <typename Iter>
  13 void check_sequence ( Iter first, Iter last, Iter sf, Iter sl )
  14 {
  15         if (sf == sl) return;
  16         for (Iter i = first; i < sf; ++i)
  17                 BOOST_CHECK(*i < *sf);
  18         BOOST_CHECK(ba::is_sorted(sf, sl));
  19         for (Iter i = sl; i < last; ++i)
  20                 BOOST_CHECK(*(sl-1) < *i);
  21 }
  22
  23 template <typename Iter, typename Pred>
  24 void check_sequence ( Iter first, Iter last, Iter sf, Iter sl, Pred p )
  25 {
  26         if (sf == sl) return;
  27         for (Iter i = first; i < sf; ++i)
  28                 BOOST_CHECK(p(*i, *sf));
  29         BOOST_CHECK(ba::is_sorted(sf, sl, p));
  30         for (Iter i = sl; i < last; ++i)
  31                 BOOST_CHECK(p(*(sl-1), *i));
  32
  33 }
  34
  35 //      for ( int i = 0; i < v.size(); ++i )
  36 //              std::cout << v[i] << ' ';
  37 //      std::cout << std::endl;
  38
  39
  40 BOOST_AUTO_TEST_CASE( test_main )
  41 {
  42         {
  43         std::vector<int> v;
  44         for ( int i = 0; i < 10; ++i )
  45                 v.push_back(i);
  46
  47         const std::vector<int>::iterator b = v.begin();
  48         ba::sort_subrange(b, v.end(), b + 3, b + 6);
  49         check_sequence   (b, v.end(), b + 3, b + 6);
  50
  51         BOOST_CHECK_EQUAL(v[3], 3);
  52         BOOST_CHECK_EQUAL(v[4], 4);
  53         BOOST_CHECK_EQUAL(v[5], 5);
  54
  55 //      Mix them up and try again - single element
  56         std::random_shuffle(v.begin(), v.end());
  57         ba::sort_subrange(b, v.end(), b + 7, b + 8);
  58         check_sequence   (b, v.end(), b + 7, b + 8);
  59
  60         BOOST_CHECK_EQUAL(v[7], 7);
  61
  62 //      Mix them up and try again - at the end
  63         std::random_shuffle(v.begin(), v.end());
  64         ba::sort_subrange(b, v.end(), b + 7, v.end());
  65         check_sequence   (b, v.end(), b + 7, v.end());
  66
  67         BOOST_CHECK_EQUAL(v[7], 7);
  68         BOOST_CHECK_EQUAL(v[8], 8);
  69         BOOST_CHECK_EQUAL(v[9], 9);
  70
  71 //      Mix them up and try again - at the beginning
  72         std::random_shuffle(v.begin(), v.end());
  73         ba::sort_subrange(b, v.end(), b, b + 2);
  74         check_sequence   (b, v.end(), b, b + 2);
  75
  76         BOOST_CHECK_EQUAL(v[0], 0);
  77         BOOST_CHECK_EQUAL(v[1], 1);
  78
  79 //      Mix them up and try again - empty subrange
  80         std::random_shuffle(v.begin(), v.end());
  81         ba::sort_subrange(b, v.end(), b, b);
  82         check_sequence   (b, v.end(), b, b);
  83
  84 //      Mix them up and try again - entire subrange
  85         std::random_shuffle(v.begin(), v.end());
  86         ba::sort_subrange(b, v.end(), b, v.end());
  87         check_sequence   (b, v.end(), b, v.end());
  88         }
  89
  90         {
  91         std::vector<int> v;
  92         for ( int i = 0; i < 10; ++i )
  93                 v.push_back(i);
  94
  95         const std::vector<int>::iterator b = v.begin();
  96         ba::sort_subrange(b, v.end(), b + 3, b + 6, std::greater<int>());
  97         check_sequence   (b, v.end(), b + 3, b + 6, std::greater<int>());
  98
  99         BOOST_CHECK_EQUAL(v[3], 6);
 100         BOOST_CHECK_EQUAL(v[4], 5);
 101         BOOST_CHECK_EQUAL(v[5], 4);
 102
 103 //      Mix them up and try again - single element
 104         std::random_shuffle(v.begin(), v.end());
 105         ba::sort_subrange(b, v.end(), b + 7, b + 8, std::greater<int>());
 106         check_sequence   (b, v.end(), b + 7, b + 8, std::greater<int>());
 107
 108         BOOST_CHECK_EQUAL(v[7], 2);
 109
 110 //      Mix them up and try again - at the end
 111         std::random_shuffle(v.begin(), v.end());
 112         ba::sort_subrange(b, v.end(), b + 7, v.end(), std::greater<int>());
 113         check_sequence   (b, v.end(), b + 7, v.end(), std::greater<int>());
 114
 115         BOOST_CHECK_EQUAL(v[7], 2);
 116         BOOST_CHECK_EQUAL(v[8], 1);
 117         BOOST_CHECK_EQUAL(v[9], 0);
 118
 119 //      Mix them up and try again - at the beginning
 120         std::random_shuffle(v.begin(), v.end());
 121         ba::sort_subrange(b, v.end(), b, b + 2, std::greater<int>());
 122         check_sequence   (b, v.end(), b, b + 2, std::greater<int>());
 123
 124         BOOST_CHECK_EQUAL(v[0], 9);
 125         BOOST_CHECK_EQUAL(v[1], 8);
 126
 127 //      Mix them up and try again - empty subrange
 128         std::random_shuffle(v.begin(), v.end());
 129         ba::sort_subrange(b, v.end(), b, b, std::greater<int>());
 130         check_sequence   (b, v.end(), b, b, std::greater<int>());
 131
 132 //      Mix them up and try again - entire subrange
 133         std::random_shuffle(v.begin(), v.end());
 134         ba::sort_subrange(b, v.end(), b, v.end(), std::greater<int>());
 135         check_sequence   (b, v.end(), b, v.end(), std::greater<int>());
 136         }
 137 }