test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // UNSUPPORTED: c++98, c++03
  11
  12 // <unordered_map>
  13
  14 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
  15 //           class Alloc = allocator<pair<const Key, T>>>
  16 // class unordered_multimap
  17
  18 // unordered_multimap(initializer_list<value_type> il);
  19
  20 #include <unordered_map>
  21 #include <string>
  22 #include <cassert>
  23 #include <cfloat>
  24 #include <cmath>
  25 #include <cstddef>
  26
  27 #include "test_macros.h"
  28 #include "../../../test_compare.h"
  29 #include "../../../test_hash.h"
  30 #include "test_allocator.h"
  31 #include "min_allocator.h"
  32
  33 int main()
  34 {
  35     {
  36         typedef std::unordered_multimap<int, std::string,
  37                                    test_hash<std::hash<int> >,
  38                                    test_compare<std::equal_to<int> >,
  39                                    test_allocator<std::pair<const int, std::string> >
  40                                    > C;
  41         typedef std::pair<int, std::string> P;
  42         C c = {
  43                 P(1, "one"),
  44                 P(2, "two"),
  45                 P(3, "three"),
  46                 P(4, "four"),
  47                 P(1, "four"),
  48                 P(2, "four"),
  49               };
  50         assert(c.bucket_count() >= 7);
  51         assert(c.size() == 6);
  52         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
  53         Eq eq = c.equal_range(1);
  54         assert(std::distance(eq.first, eq.second) == 2);
  55         C::const_iterator i = eq.first;
  56         assert(i->first == 1);
  57         assert(i->second == "one");
  58         ++i;
  59         assert(i->first == 1);
  60         assert(i->second == "four");
  61         eq = c.equal_range(2);
  62         assert(std::distance(eq.first, eq.second) == 2);
  63         i = eq.first;
  64         assert(i->first == 2);
  65         assert(i->second == "two");
  66         ++i;
  67         assert(i->first == 2);
  68         assert(i->second == "four");
  69
  70         eq = c.equal_range(3);
  71         assert(std::distance(eq.first, eq.second) == 1);
  72         i = eq.first;
  73         assert(i->first == 3);
  74         assert(i->second == "three");
  75         eq = c.equal_range(4);
  76         assert(std::distance(eq.first, eq.second) == 1);
  77         i = eq.first;
  78         assert(i->first == 4);
  79         assert(i->second == "four");
  80         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
  81         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
  82         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
  83         assert(c.max_load_factor() == 1);
  84         assert(c.hash_function() == test_hash<std::hash<int> >());
  85         assert(c.key_eq() == test_compare<std::equal_to<int> >());
  86         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
  87     }
  88     {
  89         typedef std::unordered_multimap<int, std::string,
  90                                    test_hash<std::hash<int> >,
  91                                    test_compare<std::equal_to<int> >,
  92                                    min_allocator<std::pair<const int, std::string> >
  93                                    > C;
  94         typedef std::pair<int, std::string> P;
  95         C c = {
  96                 P(1, "one"),
  97                 P(2, "two"),
  98                 P(3, "three"),
  99                 P(4, "four"),
 100                 P(1, "four"),
 101                 P(2, "four"),
 102               };
 103         assert(c.bucket_count() >= 7);
 104         assert(c.size() == 6);
 105         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
 106         Eq eq = c.equal_range(1);
 107         assert(std::distance(eq.first, eq.second) == 2);
 108         C::const_iterator i = eq.first;
 109         assert(i->first == 1);
 110         assert(i->second == "one");
 111         ++i;
 112         assert(i->first == 1);
 113         assert(i->second == "four");
 114         eq = c.equal_range(2);
 115         assert(std::distance(eq.first, eq.second) == 2);
 116         i = eq.first;
 117         assert(i->first == 2);
 118         assert(i->second == "two");
 119         ++i;
 120         assert(i->first == 2);
 121         assert(i->second == "four");
 122
 123         eq = c.equal_range(3);
 124         assert(std::distance(eq.first, eq.second) == 1);
 125         i = eq.first;
 126         assert(i->first == 3);
 127         assert(i->second == "three");
 128         eq = c.equal_range(4);
 129         assert(std::distance(eq.first, eq.second) == 1);
 130         i = eq.first;
 131         assert(i->first == 4);
 132         assert(i->second == "four");
 133         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 134         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 135         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 136         assert(c.max_load_factor() == 1);
 137         assert(c.hash_function() == test_hash<std::hash<int> >());
 138         assert(c.key_eq() == test_compare<std::equal_to<int> >());
 139         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 140     }
 141 #if TEST_STD_VER > 11
 142     {
 143         typedef std::pair<int, std::string> P;
 144         typedef test_allocator<std::pair<const int, std::string>> A;
 145         typedef test_hash<std::hash<int>> HF;
 146         typedef test_compare<std::equal_to<int>> Comp;
 147         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 148
 149         A a(42);
 150         C c ({
 151                 P(1, "one"),
 152                 P(2, "two"),
 153                 P(3, "three"),
 154                 P(4, "four"),
 155                 P(1, "four"),
 156                 P(2, "four"),
 157               }, 12, a );
 158         assert(c.bucket_count() >= 12);
 159         assert(c.size() == 6);
 160         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
 161         Eq eq = c.equal_range(1);
 162         assert(std::distance(eq.first, eq.second) == 2);
 163         C::const_iterator i = eq.first;
 164         assert(i->first == 1);
 165         assert(i->second == "one");
 166         ++i;
 167         assert(i->first == 1);
 168         assert(i->second == "four");
 169         eq = c.equal_range(2);
 170         assert(std::distance(eq.first, eq.second) == 2);
 171         i = eq.first;
 172         assert(i->first == 2);
 173         assert(i->second == "two");
 174         ++i;
 175         assert(i->first == 2);
 176         assert(i->second == "four");
 177
 178         eq = c.equal_range(3);
 179         assert(std::distance(eq.first, eq.second) == 1);
 180         i = eq.first;
 181         assert(i->first == 3);
 182         assert(i->second == "three");
 183         eq = c.equal_range(4);
 184         assert(std::distance(eq.first, eq.second) == 1);
 185         i = eq.first;
 186         assert(i->first == 4);
 187         assert(i->second == "four");
 188         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 189         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 190         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 191         assert(c.max_load_factor() == 1);
 192         assert(c.hash_function() == HF());
 193         assert(c.key_eq() == Comp());
 194         assert(c.get_allocator() == a);
 195         assert(!(c.get_allocator() == A()));
 196     }
 197     {
 198         typedef std::pair<int, std::string> P;
 199         typedef test_allocator<std::pair<const int, std::string>> A;
 200         typedef test_hash<std::hash<int>> HF;
 201         typedef test_compare<std::equal_to<int>> Comp;
 202         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
 203
 204         HF hf(42);
 205         A a(43);
 206         C c ({
 207                 P(1, "one"),
 208                 P(2, "two"),
 209                 P(3, "three"),
 210                 P(4, "four"),
 211                 P(1, "four"),
 212                 P(2, "four"),
 213               }, 12, hf, a );
 214         assert(c.bucket_count() >= 12);
 215         assert(c.size() == 6);
 216         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
 217         Eq eq = c.equal_range(1);
 218         assert(std::distance(eq.first, eq.second) == 2);
 219         C::const_iterator i = eq.first;
 220         assert(i->first == 1);
 221         assert(i->second == "one");
 222         ++i;
 223         assert(i->first == 1);
 224         assert(i->second == "four");
 225         eq = c.equal_range(2);
 226         assert(std::distance(eq.first, eq.second) == 2);
 227         i = eq.first;
 228         assert(i->first == 2);
 229         assert(i->second == "two");
 230         ++i;
 231         assert(i->first == 2);
 232         assert(i->second == "four");
 233
 234         eq = c.equal_range(3);
 235         assert(std::distance(eq.first, eq.second) == 1);
 236         i = eq.first;
 237         assert(i->first == 3);
 238         assert(i->second == "three");
 239         eq = c.equal_range(4);
 240         assert(std::distance(eq.first, eq.second) == 1);
 241         i = eq.first;
 242         assert(i->first == 4);
 243         assert(i->second == "four");
 244         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 245         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 246         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 247         assert(c.max_load_factor() == 1);
 248         assert(c.hash_function() == hf);
 249         assert(!(c.hash_function() == HF()));
 250         assert(c.key_eq() == Comp());
 251         assert(c.get_allocator() == a);
 252         assert(!(c.get_allocator() == A()));
 253     }
 254 #endif // TEST_STD_VER > 11
 255 }