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

   1 // { dg-options "-std=gnu++17" }
   2 // { dg-do compile { target c++17 } }
   3
   4 #include <map>
   5 #include <testsuite_allocator.h>
   6 #include <testsuite_iterators.h>
   7
   8 using __gnu_test::SimpleAllocator;
   9 using value_type = std::multimap<int, double>::value_type;
  10
  11 static_assert(std::is_same_v<
  12               decltype(std::multimap{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
  13               std::multimap<int, double>>);
  14
  15 static_assert(std::is_same_v<
  16               decltype(std::multimap{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
  17               std::multimap<int, double>>);
  18
  19 static_assert(std::is_same_v<
  20               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
  21               std::multimap<int, double>>);
  22
  23 static_assert(std::is_same_v<
  24               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
  25               std::multimap<int, double>>);
  26
  27 static_assert(std::is_same_v<
  28               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  29                                 std::less<int>{}, {}}),
  30               std::multimap<int, double>>);
  31
  32 static_assert(std::is_same_v<
  33               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  34                     std::less<int>{}, {}}),
  35               std::multimap<int, double>>);
  36
  37 /* This is not deducible, {} could be deduced as _Compare or _Allocator.
  38 static_assert(std::is_same_v<
  39               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  40                                      {}}),
  41               std::multimap<int, double>>);
  42 */
  43
  44 static_assert(std::is_same_v<
  45               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  46                     {}}),
  47               std::multimap<int, double>>);
  48
  49 static_assert(std::is_same_v<
  50               decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
  51                                      {}, SimpleAllocator<value_type>{}}),
  52               std::multimap<int, double, std::less<int>,
  53                        SimpleAllocator<value_type>>>);
  54
  55 static_assert(std::is_same_v<
  56               decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  57                                      {}, SimpleAllocator<value_type>{}}),
  58               std::multimap<int, double, std::less<int>,
  59                             SimpleAllocator<value_type>>>);
  60
  61 void f()
  62 {
  63   std::multimap<int, double> x;
  64   static_assert(std::is_same_v<
  65                 decltype(std::multimap(x.begin(), x.end())),
  66                 std::multimap<int, double>>);
  67
  68   static_assert(std::is_same_v<
  69                 decltype(std::multimap{x.begin(), x.end(),
  70                                        std::less<int>{},
  71                                        std::allocator<value_type>{}}),
  72                 std::multimap<int, double>>);
  73
  74   static_assert(std::is_same_v<
  75                 decltype(std::multimap{x.begin(), x.end(),
  76                                        std::less<int>{}, {}}),
  77                 std::multimap<int, double>>);
  78
  79   static_assert(std::is_same_v<
  80                 decltype(std::multimap(x.begin(), x.end(),
  81                                        {})),
  82                 std::multimap<int, double>>);
  83
  84   static_assert(std::is_same_v<
  85                 decltype(std::multimap{x.begin(), x.end(),
  86                       {},
  87                       std::allocator<value_type>{}}),
  88                 std::multimap<int, double>>);
  89
  90   static_assert(std::is_same_v<
  91                 decltype(std::multimap{x.begin(), x.end(),
  92                                        {},
  93                                        SimpleAllocator<value_type>{}}),
  94                 std::multimap<int, double, std::less<int>,
  95                               SimpleAllocator<value_type>>>);
  96 }
  97
  98 using __gnu_test::test_container;
  99 using __gnu_test::input_iterator_wrapper;
 100
 101 void g()
 102 {
 103   value_type array[1];
 104   test_container<value_type, input_iterator_wrapper> x(array);
 105
 106   static_assert(std::is_same_v<
 107                 decltype(std::multimap(x.begin(), x.end())),
 108                 std::multimap<int, double>>);
 109
 110   static_assert(std::is_same_v<
 111                 decltype(std::multimap{x.begin(), x.end(),
 112                                        std::less<int>{},
 113                                        std::allocator<value_type>{}}),
 114                 std::multimap<int, double>>);
 115
 116   static_assert(std::is_same_v<
 117                 decltype(std::multimap{x.begin(), x.end(),
 118                                        std::less<int>{}, {}}),
 119                 std::multimap<int, double>>);
 120
 121   static_assert(std::is_same_v<
 122                 decltype(std::multimap(x.begin(), x.end(),
 123                                        {})),
 124                 std::multimap<int, double>>);
 125
 126   static_assert(std::is_same_v<
 127                 decltype(std::multimap{x.begin(), x.end(),
 128                                        {},
 129                                        std::allocator<value_type>{}}),
 130                 std::multimap<int, double>>);
 131
 132   static_assert(std::is_same_v<
 133                 decltype(std::multimap{x.begin(), x.end(),
 134                                        {},
 135                                        SimpleAllocator<value_type>{}}),
 136                 std::multimap<int, double, std::less<int>,
 137                          SimpleAllocator<value_type>>>);
 138 }
 139
 140 void h()
 141 {
 142   std::pair<int, double> array[1];
 143   test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
 144
 145   static_assert(std::is_same_v<
 146                 decltype(std::multimap(x.begin(), x.end())),
 147                 std::multimap<int, double>>);
 148
 149   static_assert(std::is_same_v<
 150                 decltype(std::multimap{x.begin(), x.end(),
 151                                        std::less<int>{},
 152                                        std::allocator<value_type>{}}),
 153                 std::multimap<int, double>>);
 154
 155   static_assert(std::is_same_v<
 156                 decltype(std::multimap{x.begin(), x.end(),
 157                                        std::less<int>{}, {}}),
 158                 std::multimap<int, double>>);
 159
 160   static_assert(std::is_same_v<
 161                 decltype(std::multimap(x.begin(), x.end(),
 162                                        {})),
 163                 std::multimap<int, double>>);
 164
 165   static_assert(std::is_same_v<
 166                 decltype(std::multimap{x.begin(), x.end(),
 167                                        {},
 168                                        std::allocator<value_type>{}}),
 169                 std::multimap<int, double>>);
 170
 171   static_assert(std::is_same_v<
 172                 decltype(std::multimap{x.begin(), x.end(),
 173                                        {},
 174                                        SimpleAllocator<value_type>{}}),
 175                 std::multimap<int, double, std::less<int>,
 176                               SimpleAllocator<value_type>>>);
 177 }