libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc

   1 // { dg-do compile { target c++17 } }
   2
   3 #include <map>
   4 #include <testsuite_allocator.h>
   5 #include <testsuite_iterators.h>
   6
   7 using __gnu_test::SimpleAllocator;
   8 using value_type = std::multimap<int, double>::value_type;
   9
  10 static_assert(std::is_same_v<
  11               decltype(std::multimap{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
  12               std::multimap<int, double>>);
  13
  14 static_assert(std::is_same_v<
  15               decltype(std::multimap{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
  16               std::multimap<int, double>>);
  17
  18 static_assert(std::is_same_v<
  19               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
  20               std::multimap<int, double>>);
  21
  22 static_assert(std::is_same_v<
  23               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
  24               std::multimap<int, double>>);
  25
  26 static_assert(std::is_same_v<
  27               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  28                                 std::less<int>{}, {}}),
  29               std::multimap<int, double>>);
  30
  31 static_assert(std::is_same_v<
  32               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  33                     std::less<int>{}, {}}),
  34               std::multimap<int, double>>);
  35
  36 /* This is not deducible, {} could be deduced as _Compare or _Allocator.
  37 static_assert(std::is_same_v<
  38               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  39                                      {}}),
  40               std::multimap<int, double>>);
  41 */
  42
  43 static_assert(std::is_same_v<
  44               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  45                     std::less<int>{}}),
  46               std::multimap<int, double>>);
  47
  48 static_assert(std::is_same_v<
  49               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  50                                      {}, SimpleAllocator<value_type>{}}),
  51               std::multimap<int, double, std::less<int>,
  52                        SimpleAllocator<value_type>>>);
  53
  54 static_assert(std::is_same_v<
  55               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  56                                      {}, SimpleAllocator<value_type>{}}),
  57               std::multimap<int, double, std::less<int>,
  58                             SimpleAllocator<value_type>>>);
  59
  60 void f()
  61 {
  62   std::multimap<int, double> x;
  63   static_assert(std::is_same_v<
  64                 decltype(std::multimap(x.begin(), x.end())),
  65                 std::multimap<int, double>>);
  66
  67   static_assert(std::is_same_v<
  68                 decltype(std::multimap{x.begin(), x.end(),
  69                                        std::less<int>{},
  70                                        std::allocator<value_type>{}}),
  71                 std::multimap<int, double>>);
  72
  73   static_assert(std::is_same_v<
  74                 decltype(std::multimap{x.begin(), x.end(),
  75                                        std::less<int>{}, {}}),
  76                 std::multimap<int, double>>);
  77
  78   static_assert(std::is_same_v<
  79                 decltype(std::multimap(x.begin(), x.end(),
  80                                        std::less<int>{})),
  81                 std::multimap<int, double>>);
  82
  83   static_assert(std::is_same_v<
  84                 decltype(std::multimap{x.begin(), x.end(),
  85                       {},
  86                       std::allocator<value_type>{}}),
  87                 std::multimap<int, double>>);
  88
  89   static_assert(std::is_same_v<
  90                 decltype(std::multimap{x.begin(), x.end(),
  91                                        {},
  92                                        SimpleAllocator<value_type>{}}),
  93                 std::multimap<int, double, std::less<int>,
  94                               SimpleAllocator<value_type>>>);
  95 }
  96
  97 using __gnu_test::test_container;
  98 using __gnu_test::input_iterator_wrapper;
  99
 100 void g()
 101 {
 102   value_type array[1];
 103   test_container<value_type, input_iterator_wrapper> x(array);
 104
 105   static_assert(std::is_same_v<
 106                 decltype(std::multimap(x.begin(), x.end())),
 107                 std::multimap<int, double>>);
 108
 109   static_assert(std::is_same_v<
 110                 decltype(std::multimap{x.begin(), x.end(),
 111                                        std::less<int>{},
 112                                        std::allocator<value_type>{}}),
 113                 std::multimap<int, double>>);
 114
 115   static_assert(std::is_same_v<
 116                 decltype(std::multimap{x.begin(), x.end(),
 117                                        std::less<int>{}, {}}),
 118                 std::multimap<int, double>>);
 119
 120   static_assert(std::is_same_v<
 121                 decltype(std::multimap(x.begin(), x.end(),
 122                                        std::less<int>{})),
 123                 std::multimap<int, double>>);
 124
 125   static_assert(std::is_same_v<
 126                 decltype(std::multimap{x.begin(), x.end(),
 127                                        {},
 128                                        std::allocator<value_type>{}}),
 129                 std::multimap<int, double>>);
 130
 131   static_assert(std::is_same_v<
 132                 decltype(std::multimap{x.begin(), x.end(),
 133                                        {},
 134                                        SimpleAllocator<value_type>{}}),
 135                 std::multimap<int, double, std::less<int>,
 136                          SimpleAllocator<value_type>>>);
 137 }
 138
 139 void h()
 140 {
 141   std::pair<int, double> array[1];
 142   test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
 143
 144   static_assert(std::is_same_v<
 145                 decltype(std::multimap(x.begin(), x.end())),
 146                 std::multimap<int, double>>);
 147
 148   static_assert(std::is_same_v<
 149                 decltype(std::multimap{x.begin(), x.end(),
 150                                        std::less<int>{},
 151                                        std::allocator<value_type>{}}),
 152                 std::multimap<int, double>>);
 153
 154   static_assert(std::is_same_v<
 155                 decltype(std::multimap{x.begin(), x.end(),
 156                                        std::less<int>{}, {}}),
 157                 std::multimap<int, double>>);
 158
 159   static_assert(std::is_same_v<
 160                 decltype(std::multimap(x.begin(), x.end(),
 161                                        std::less<int>{})),
 162                 std::multimap<int, double>>);
 163
 164   static_assert(std::is_same_v<
 165                 decltype(std::multimap{x.begin(), x.end(),
 166                                        {},
 167                                        std::allocator<value_type>{}}),
 168                 std::multimap<int, double>>);
 169
 170   static_assert(std::is_same_v<
 171                 decltype(std::multimap{x.begin(), x.end(),
 172                                        {},
 173                                        SimpleAllocator<value_type>{}}),
 174                 std::multimap<int, double, std::less<int>,
 175                               SimpleAllocator<value_type>>>);
 176 }
 177
 178 template<typename T, typename U> struct require_same;
 179 template<typename T> struct require_same<T, T> { using type = void; };
 180
 181 template<typename T, typename U>
 182   typename require_same<T, U>::type
 183   check_type(U&) { }
 184
 185 struct Pool;
 186
 187 template<typename T>
 188 struct Alloc : __gnu_test::SimpleAllocator<T>
 189 {
 190   Alloc(Pool*) { }
 191
 192   template<typename U>
 193     Alloc(const Alloc<U>&) { }
 194 };
 195
 196 void
 197 test_p1518r2()
 198 {
 199   // P1518R2 - Stop overconstraining allocators in container deduction guides.
 200   // This is a C++23 feature but we support it for C++17 too.
 201
 202   using PairAlloc = Alloc<std::pair<const unsigned, void*>>;
 203   using MMap = std::multimap<unsigned, void*, std::greater<>, PairAlloc>;
 204   Pool* p = nullptr;
 205   MMap m(p);
 206
 207   std::multimap s1(m, p);
 208   check_type<MMap>(s1);
 209
 210   std::multimap s2(std::move(m), p);
 211   check_type<MMap>(s2);
 212 }