ceph/src/boost/libs/mp11/test/tuple_transform.cpp

   1
   2 // Copyright 2020 Hans Dembinski.
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 //
   6 // See accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt
   8
   9 #include <boost/mp11/tuple.hpp>
  10 #include <boost/core/lightweight_test.hpp>
  11 #include <boost/core/lightweight_test_trait.hpp>
  12 #include <tuple>
  13 #include <utility>
  14 #include <iosfwd>
  15
  16 // family of test types with state
  17 template <int N>
  18 struct T {
  19     int value;
  20     T() : value{N} {};
  21     explicit T(int n) : value{n} {}
  22 };
  23
  24 template <int N>
  25 std::ostream& operator<<( std::ostream& os, T<N> const& t )
  26 {
  27     os << t.value;
  28     return os;
  29 }
  30
  31 // test function changes type and value
  32 struct F {
  33     template<int N, int M=1> T<N+M> operator()( T<N> a, T<M> b={} ) const
  34     {
  35         return T<N+M>{a.value + b.value + 1};
  36     }
  37 };
  38
  39 int main()
  40 {
  41     using boost::mp11::tuple_transform;
  42
  43     {
  44         std::tuple<T<1>, T<2>, T<3>> tp;
  45         std::tuple<T<4>, T<5>, T<6>> tp2;
  46
  47         {
  48             std::tuple<T<2>, T<3>, T<4>> s = tuple_transform( F{}, tp );
  49             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
  50             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
  51             BOOST_TEST_EQ( std::get<2>(s).value, 5 );
  52         }
  53
  54         {
  55             std::tuple<T<2>, T<3>, T<4>> s = tuple_transform( F{}, std::move(tp) );
  56             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
  57             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
  58             BOOST_TEST_EQ( std::get<2>(s).value, 5 );
  59         }
  60
  61         {
  62             std::tuple<T<5>, T<7>, T<9>> s = tuple_transform( F{}, tp, tp2 );
  63             BOOST_TEST_EQ( std::get<0>(s).value, 6 );
  64             BOOST_TEST_EQ( std::get<1>(s).value, 8 );
  65             BOOST_TEST_EQ( std::get<2>(s).value, 10 );
  66         }
  67
  68         {
  69             std::tuple<T<5>, T<7>, T<9>> s = tuple_transform(
  70                 F{}, std::move(tp), std::move(tp2)
  71             );
  72             BOOST_TEST_EQ( std::get<0>(s).value, 6 );
  73             BOOST_TEST_EQ( std::get<1>(s).value, 8 );
  74             BOOST_TEST_EQ( std::get<2>(s).value, 10 );
  75         }
  76     }
  77
  78     {
  79         std::tuple<T<1>, T<2>, T<3>> const tp;
  80         std::tuple<T<4>, T<5>, T<6>> const tp2;
  81
  82         {
  83             std::tuple<T<2>, T<3>, T<4>> s = tuple_transform( F{}, tp );
  84             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
  85             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
  86             BOOST_TEST_EQ( std::get<2>(s).value, 5 );
  87         }
  88
  89         {
  90             std::tuple<T<2>, T<3>, T<4>> s = tuple_transform( F{}, std::move(tp) );
  91             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
  92             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
  93             BOOST_TEST_EQ( std::get<2>(s).value, 5 );
  94         }
  95
  96         {
  97             std::tuple<T<5>, T<7>, T<9>> s = tuple_transform( F{}, tp, tp2 );
  98             BOOST_TEST_EQ( std::get<0>(s).value, 6 );
  99             BOOST_TEST_EQ( std::get<1>(s).value, 8 );
 100             BOOST_TEST_EQ( std::get<2>(s).value, 10 );
 101         }
 102
 103         {
 104             std::tuple<T<5>, T<7>, T<9>> s = tuple_transform(
 105                 F{}, std::move(tp), std::move(tp2)
 106             );
 107             BOOST_TEST_EQ( std::get<0>(s).value, 6 );
 108             BOOST_TEST_EQ( std::get<1>(s).value, 8 );
 109             BOOST_TEST_EQ( std::get<2>(s).value, 10 );
 110         }
 111     }
 112
 113     {
 114         std::pair<T<1>, T<2>> tp;
 115         std::pair<T<3>, T<4>> tp2;
 116
 117         {
 118             std::tuple<T<2>, T<3>> s = tuple_transform( F{}, tp );
 119             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
 120             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
 121         }
 122
 123         {
 124             std::tuple<T<2>, T<3>> s = tuple_transform( F{}, std::move(tp) );
 125             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
 126             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
 127         }
 128
 129         {
 130             std::tuple<T<4>, T<6>> s = tuple_transform( F{}, tp, tp2 );
 131             BOOST_TEST_EQ( std::get<0>(s).value, 5 );
 132             BOOST_TEST_EQ( std::get<1>(s).value, 7 );
 133         }
 134
 135         {
 136             std::tuple<T<4>, T<6>> s = tuple_transform(
 137                 F{}, std::move(tp), std::move(tp2)
 138             );
 139             BOOST_TEST_EQ( std::get<0>(s).value, 5 );
 140             BOOST_TEST_EQ( std::get<1>(s).value, 7 );
 141         }
 142     }
 143
 144     {
 145         std::pair<T<1>, T<2>> const tp;
 146         std::pair<T<3>, T<4>> const tp2;
 147
 148         {
 149             std::tuple<T<2>, T<3>> s = tuple_transform( F{}, tp );
 150             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
 151             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
 152         }
 153
 154         {
 155             std::tuple<T<2>, T<3>> s = tuple_transform( F{}, std::move(tp) );
 156             BOOST_TEST_EQ( std::get<0>(s).value, 3 );
 157             BOOST_TEST_EQ( std::get<1>(s).value, 4 );
 158         }
 159
 160         {
 161             std::tuple<T<4>, T<6>> s = tuple_transform( F{}, tp, tp2 );
 162             BOOST_TEST_EQ( std::get<0>(s).value, 5 );
 163             BOOST_TEST_EQ( std::get<1>(s).value, 7 );
 164         }
 165
 166         {
 167             std::tuple<T<4>, T<6>> s = tuple_transform(
 168                 F{}, std::move(tp), std::move(tp2)
 169             );
 170             BOOST_TEST_EQ( std::get<0>(s).value, 5 );
 171             BOOST_TEST_EQ( std::get<1>(s).value, 7 );
 172         }
 173     }
 174
 175     {
 176         std::tuple<> tp;
 177
 178         {
 179             auto s = tuple_transform( F{}, tp );
 180             BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(s), std::tuple<>>));
 181         }
 182
 183         {
 184             auto s = tuple_transform( F{}, std::move(tp) );
 185             BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(s), std::tuple<>>));
 186         }
 187     }
 188
 189     return boost::report_errors();
 190 }