ceph/src/boost/libs/hana/test/_include/auto/slice.hpp

   1 // Copyright Louis Dionne 2013-2017
   2 // Distributed under the Boost Software License, Version 1.0.
   3 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
   4
   5 #ifndef BOOST_HANA_TEST_AUTO_SLICE_HPP
   6 #define BOOST_HANA_TEST_AUTO_SLICE_HPP
   7
   8 #include <boost/hana/assert.hpp>
   9 #include <boost/hana/equal.hpp>
  10 #include <boost/hana/integral_constant.hpp>
  11 #include <boost/hana/range.hpp>
  12 #include <boost/hana/slice.hpp>
  13 #include <boost/hana/tuple.hpp>
  14
  15 #include "test_case.hpp"
  16 #include <laws/base.hpp>
  17 #include <support/seq.hpp>
  18
  19 #include <cstddef>
  20
  21
  22 TestCase test_slice{[]{
  23     namespace hana = boost::hana;
  24     using hana::test::ct_eq;
  25     constexpr auto foldable = ::seq;
  26
  27     struct undefined { };
  28
  29     //////////////////////////////////////////////////////////////////////////
  30     // Test with arbitrary indices
  31     //////////////////////////////////////////////////////////////////////////
  32     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  33         hana::slice(MAKE_TUPLE(),
  34                     foldable()),
  35         MAKE_TUPLE()
  36     ));
  37     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  38         hana::slice(MAKE_TUPLE(undefined{}),
  39                     foldable()),
  40         MAKE_TUPLE()
  41     ));
  42     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  43         hana::slice(MAKE_TUPLE(undefined{}, undefined{}),
  44                     foldable()),
  45         MAKE_TUPLE()
  46     ));
  47
  48     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  49         hana::slice(MAKE_TUPLE(ct_eq<0>{}),
  50                     foldable(hana::size_c<0>)),
  51         MAKE_TUPLE(ct_eq<0>{})
  52     ));
  53     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  54         hana::slice(MAKE_TUPLE(ct_eq<0>{}, undefined{}),
  55                     foldable(hana::size_c<0>)),
  56         MAKE_TUPLE(ct_eq<0>{})
  57     ));
  58     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  59         hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}),
  60                     foldable(hana::size_c<1>)),
  61         MAKE_TUPLE(ct_eq<1>{})
  62     ));
  63
  64     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  65         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  66                     foldable(hana::size_c<0>, hana::size_c<1>)),
  67         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
  68     ));
  69     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  70         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  71                     foldable(hana::size_c<1>, hana::size_c<0>)),
  72         MAKE_TUPLE(ct_eq<1>{}, ct_eq<0>{})
  73     ));
  74     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  75         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  76                     foldable(hana::size_c<0>, hana::size_c<0>)),
  77         MAKE_TUPLE(ct_eq<0>{}, ct_eq<0>{})
  78     ));
  79     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  80         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  81                     foldable(hana::size_c<1>, hana::size_c<1>)),
  82         MAKE_TUPLE(ct_eq<1>{}, ct_eq<1>{})
  83     ));
  84
  85     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  86         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  87               foldable(hana::size_c<0>, hana::size_c<1>, hana::size_c<2>)),
  88         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
  89     ));
  90     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  91         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  92                     foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>)),
  93         MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{})
  94     ));
  95
  96     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  97         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  98                     foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>, hana::size_c<0>)),
  99         MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{}, ct_eq<0>{})
 100     ));
 101
 102     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 103         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
 104                     foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>, hana::size_c<0>, hana::size_c<1>)),
 105         MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{}, ct_eq<0>{}, ct_eq<1>{})
 106     ));
 107
 108     // Try with a tuple_c
 109     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 110         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 111                     hana::tuple_c<unsigned, 1, 3, 2>),
 112         MAKE_TUPLE(ct_eq<1>{}, ct_eq<3>{}, ct_eq<2>{})
 113     ));
 114
 115
 116
 117     //////////////////////////////////////////////////////////////////////////
 118     // Test with a `range` (check the optimization for contiguous indices)
 119     //////////////////////////////////////////////////////////////////////////
 120     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 121         hana::slice(MAKE_TUPLE(),
 122                     hana::range_c<std::size_t, 0, 0>),
 123         MAKE_TUPLE()
 124     ));
 125     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 126         hana::slice(MAKE_TUPLE(undefined{}),
 127                     hana::range_c<std::size_t, 0, 0>),
 128         MAKE_TUPLE()
 129     ));
 130     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 131         hana::slice(MAKE_TUPLE(undefined{}, undefined{}),
 132                     hana::range_c<std::size_t, 0, 0>),
 133         MAKE_TUPLE()
 134     ));
 135
 136     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 137         hana::slice(MAKE_TUPLE(ct_eq<0>{}),
 138                     hana::range_c<std::size_t, 0, 1>),
 139         MAKE_TUPLE(ct_eq<0>{})
 140     ));
 141     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 142         hana::slice(MAKE_TUPLE(ct_eq<0>{}, undefined{}),
 143                     hana::range_c<std::size_t, 0, 1>),
 144         MAKE_TUPLE(ct_eq<0>{})
 145     ));
 146
 147     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 148         hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}),
 149                     hana::range_c<std::size_t, 1, 2>),
 150         MAKE_TUPLE(ct_eq<1>{})
 151     ));
 152     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 153         hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, undefined{}),
 154                     hana::range_c<std::size_t, 1, 2>),
 155         MAKE_TUPLE(ct_eq<1>{})
 156     ));
 157
 158     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 159         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
 160                     hana::range_c<std::size_t, 0, 2>),
 161         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
 162     ));
 163     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 164         hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, undefined{}),
 165                     hana::range_c<std::size_t, 0, 2>),
 166         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
 167     ));
 168
 169     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 170         hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, ct_eq<2>{}),
 171                     hana::range_c<std::size_t, 1, 3>),
 172         MAKE_TUPLE(ct_eq<1>{}, ct_eq<2>{})
 173     ));
 174
 175     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 176         hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, ct_eq<2>{}, undefined{}),
 177                     hana::range_c<std::size_t, 1, 3>),
 178         MAKE_TUPLE(ct_eq<1>{}, ct_eq<2>{})
 179     ));
 180 }};
 181
 182 #endif // !BOOST_HANA_TEST_AUTO_SLICE_HPP