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

   1 // { dg-options "-std=gnu++17" }
   2 // { dg-do compile { target c++17 } }
   3
   4 #include <unordered_map>
   5 #include <testsuite_allocator.h>
   6
   7 using __gnu_test::SimpleAllocator;
   8
   9 static_assert(std::is_same_v<
  10               decltype(std::unordered_multimap{std::pair{1, 2.0},
  11                     {2, 3.0}, {3, 4.0}}),
  12               std::unordered_multimap<int, double>>);
  13
  14 static_assert(std::is_same_v<
  15               decltype(std::unordered_multimap{{std::pair{1, 2.0},
  16                       {2, 3.0}, {3, 4.0}}}),
  17               std::unordered_multimap<int, double>>);
  18
  19 static_assert(std::is_same_v<
  20               decltype(std::unordered_multimap{{std::pair{1, 2.0},
  21                       {2, 3.0}, {3, 4.0}},
  22                     {}, std::hash<int>{}, {}}),
  23               std::unordered_multimap<int, double>>);
  24
  25 static_assert(std::is_same_v<
  26               decltype(std::unordered_multimap{{std::pair{1, 2.0},
  27                       {2, 3.0}, {3, 4.0}},
  28                     {}}),
  29               std::unordered_multimap<int, double>>);
  30
  31 static_assert(std::is_same_v<
  32               decltype(std::unordered_multimap{
  33                 {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  34                 1, std::hash<int>{}}),
  35               std::unordered_multimap<int, double>>);
  36
  37 static_assert(std::is_same_v<
  38               decltype(std::unordered_multimap{
  39                 {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  40                 1, std::hash<int>{},
  41                 SimpleAllocator<std::pair<const int, double>>{}}),
  42               std::unordered_multimap<int, double, std::hash<int>,
  43               std::equal_to<int>,
  44               SimpleAllocator<std::pair<const int, double>>>>);
  45
  46 static_assert(std::is_same_v<
  47               decltype(std::unordered_multimap{
  48                 {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
  49                 {}, {}, {},
  50                 SimpleAllocator<std::pair<const int, double>>{}}),
  51               std::unordered_multimap<int, double, std::hash<int>,
  52               std::equal_to<int>,
  53               SimpleAllocator<std::pair<const int, double>>>>);
  54
  55
  56 void f()
  57 {
  58   std::unordered_multimap<int, double> x;
  59
  60   static_assert(std::is_same_v<
  61                 decltype(std::unordered_multimap(x.begin(), x.end())),
  62                 std::unordered_multimap<int, double>>);
  63
  64   static_assert(std::is_same_v<
  65                 decltype(std::unordered_multimap{x.begin(), x.end(),
  66                       {}, std::hash<int>{}, {},
  67                       std::allocator<std::pair<const int, double>>{}}),
  68                 std::unordered_multimap<int, double>>);
  69
  70   static_assert(std::is_same_v<
  71                 decltype(std::unordered_multimap{x.begin(), x.end(),
  72                       {}, std::hash<int>{}, {}}),
  73                 std::unordered_multimap<int, double>>);
  74
  75   static_assert(std::is_same_v<
  76                 decltype(std::unordered_multimap(x.begin(), x.end(),
  77                                   {})),
  78                 std::unordered_multimap<int, double>>);
  79
  80   static_assert(std::is_same_v<
  81                 decltype(std::unordered_multimap(x.begin(), x.end(), 1)),
  82                 std::unordered_multimap<int, double>>);
  83
  84   static_assert(std::is_same_v<
  85                 decltype(std::unordered_multimap{x.begin(), x.end(),
  86                       {},
  87                       std::allocator<std::pair<const int, double>>{}}),
  88                 std::unordered_multimap<int, double>>);
  89
  90   static_assert(std::is_same_v<
  91                 decltype(std::unordered_multimap{x.begin(), x.end(),
  92                       {},
  93                       SimpleAllocator<std::pair<const int, double>>{}}),
  94                 std::unordered_multimap<int, double, std::hash<int>,
  95                 std::equal_to<int>,
  96                 SimpleAllocator<std::pair<const int, double>>>>);
  97
  98   static_assert(std::is_same_v<
  99                 decltype(std::unordered_multimap{x.begin(), x.end(),
 100                       1, std::hash<int>{},
 101                       std::allocator<std::pair<const int, double>>{}}),
 102                 std::unordered_multimap<int, double>>);
 103
 104   static_assert(std::is_same_v<
 105                 decltype(std::unordered_multimap{x.begin(), x.end(),
 106                       1, std::hash<int>{},
 107                       SimpleAllocator<std::pair<const int, double>>{}}),
 108                 std::unordered_multimap<int, double, std::hash<int>,
 109                 std::equal_to<int>,
 110                 SimpleAllocator<std::pair<const int, double>>>>);
 111
 112   static_assert(std::is_same_v<
 113                 decltype(std::unordered_multimap{x.begin(), x.end(),
 114                       {}, {}, {},
 115                       std::allocator<std::pair<const int, double>>{}}),
 116                 std::unordered_multimap<int, double>>);
 117
 118   static_assert(std::is_same_v<
 119                 decltype(std::unordered_multimap{x.begin(), x.end(),
 120                       {}, {}, {},
 121                       SimpleAllocator<std::pair<const int, double>>{}}),
 122                 std::unordered_multimap<int, double, std::hash<int>,
 123                 std::equal_to<int>,
 124                 SimpleAllocator<std::pair<const int, double>>>>);
 125 }