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

   1 // { dg-do compile { target c++17 } }
   2
   3 #include <set>
   4 #include <testsuite_allocator.h>
   5 #include <testsuite_iterators.h>
   6
   7 using __gnu_test::SimpleAllocator;
   8 using value_type = std::multiset<int>::value_type;
   9
  10 static_assert(std::is_same_v<
  11               decltype(std::multiset{1, 2, 3}),
  12               std::multiset<int>>);
  13
  14 static_assert(std::is_same_v<
  15               decltype(std::multiset{1, 2, 3}),
  16               std::multiset<int>>);
  17
  18 static_assert(std::is_same_v<
  19               decltype(std::multiset{{1, 2, 3}, std::less<int>{}, {}}),
  20               std::multiset<int>>);
  21
  22 static_assert(std::is_same_v<
  23               decltype(std::multiset{{1, 2, 3}, std::less<int>{}}),
  24               std::multiset<int>>);
  25
  26 static_assert(std::is_same_v<
  27               decltype(std::multiset{{1, 2, 3}, SimpleAllocator<int>{}}),
  28               std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
  29
  30 static_assert(std::is_same_v<
  31               decltype(std::multiset{{1, 2, 3}, {}, SimpleAllocator<int>{}}),
  32               std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
  33
  34 void f()
  35 {
  36   std::multiset<int> x;
  37
  38   static_assert(std::is_same_v<
  39                 decltype(std::multiset(x.begin(), x.end())),
  40                 std::multiset<int>>);
  41
  42   static_assert(std::is_same_v<
  43                 decltype(std::multiset{x.begin(), x.end(),
  44                       std::less<int>{},
  45                       std::allocator<int>{}}),
  46                 std::multiset<int>>);
  47
  48   static_assert(std::is_same_v<
  49                 decltype(std::multiset{x.begin(), x.end(),
  50                       std::less<int>{}, {}}),
  51                 std::multiset<int>>);
  52
  53   static_assert(std::is_same_v<
  54                 decltype(std::multiset(x.begin(), x.end(),
  55                                   std::less<int>{})),
  56                 std::multiset<int>>);
  57
  58   static_assert(std::is_same_v<
  59                 decltype(std::multiset{x.begin(), x.end(),
  60                                        std::allocator<int>{}}),
  61                 std::multiset<int>>);
  62
  63   static_assert(std::is_same_v<
  64                 decltype(std::multiset{x.begin(), x.end(),
  65                                        SimpleAllocator<int>{}}),
  66                 std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
  67
  68   static_assert(std::is_same_v<
  69                 decltype(std::multiset{x.begin(), x.end(),
  70                       {},
  71                       std::allocator<int>{}}),
  72                 std::multiset<int>>);
  73
  74   static_assert(std::is_same_v<
  75                 decltype(std::multiset{x.begin(), x.end(),
  76                       {},
  77                       SimpleAllocator<int>{}}),
  78                 std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
  79 }
  80
  81 using __gnu_test::test_container;
  82 using __gnu_test::input_iterator_wrapper;
  83
  84 void g()
  85 {
  86   value_type array[1];
  87   test_container<value_type, input_iterator_wrapper> x(array);
  88
  89   static_assert(std::is_same_v<
  90                 decltype(std::multiset(x.begin(), x.end())),
  91                 std::multiset<int>>);
  92
  93   static_assert(std::is_same_v<
  94                 decltype(std::multiset{x.begin(), x.end(),
  95                                   std::less<int>{},
  96                                   std::allocator<value_type>{}}),
  97                 std::multiset<int>>);
  98
  99   static_assert(std::is_same_v<
 100                 decltype(std::multiset{x.begin(), x.end(),
 101                                   std::less<int>{}, {}}),
 102                 std::multiset<int>>);
 103
 104   static_assert(std::is_same_v<
 105                 decltype(std::multiset(x.begin(), x.end(),
 106                                   std::less<int>{})),
 107                 std::multiset<int>>);
 108
 109   static_assert(std::is_same_v<
 110                 decltype(std::multiset{x.begin(), x.end(),
 111                                   std::allocator<value_type>{}}),
 112                 std::multiset<int>>);
 113
 114   static_assert(std::is_same_v<
 115                 decltype(std::multiset{x.begin(), x.end(),
 116                                   SimpleAllocator<value_type>{}}),
 117                 std::multiset<int, std::less<int>,
 118                          SimpleAllocator<value_type>>>);
 119
 120   static_assert(std::is_same_v<
 121                 decltype(std::multiset{x.begin(), x.end(),
 122                                   {},
 123                                   std::allocator<value_type>{}}),
 124                 std::multiset<int>>);
 125
 126   static_assert(std::is_same_v<
 127                 decltype(std::multiset{x.begin(), x.end(),
 128                                   {},
 129                                   SimpleAllocator<value_type>{}}),
 130                 std::multiset<int, std::less<int>,
 131                          SimpleAllocator<value_type>>>);
 132 }
 133
 134 template<typename T, typename U> struct require_same;
 135 template<typename T> struct require_same<T, T> { using type = void; };
 136
 137 template<typename T, typename U>
 138   typename require_same<T, U>::type
 139   check_type(U&) { }
 140
 141 struct Pool;
 142
 143 template<typename T>
 144 struct Alloc : __gnu_test::SimpleAllocator<T>
 145 {
 146   Alloc(Pool*) { }
 147
 148   template<typename U>
 149     Alloc(const Alloc<U>&) { }
 150 };
 151
 152 void
 153 test_p1518r2()
 154 {
 155   // P1518R2 - Stop overconstraining allocators in container deduction guides.
 156   // This is a C++23 feature but we support it for C++17 too.
 157
 158   using MSet = std::multiset<unsigned, std::greater<>, Alloc<unsigned>>;
 159   Pool* p = nullptr;
 160   MSet s(p);
 161
 162   std::multiset s1(s, p);
 163   check_type<MSet>(s1);
 164
 165   std::multiset s2(std::move(s), p);
 166   check_type<MSet>(s2);
 167 }