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// <unordered_map> 11 12// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13// class Alloc = allocator<pair<const Key, T>>> 14// class unordered_multimap 15 16// unordered_multimap(unordered_multimap&& u, const allocator_type& a); 17 18#include <iostream> 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 33int main() 34{ 35#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 36 { 37 typedef std::pair<int, std::string> P; 38 typedef test_allocator<std::pair<const int, std::string>> A; 39 typedef std::unordered_multimap<int, std::string, 40 test_hash<std::hash<int> >, 41 test_compare<std::equal_to<int> >, 42 A 43 > C; 44 P a[] = 45 { 46 P(1, "one"), 47 P(2, "two"), 48 P(3, "three"), 49 P(4, "four"), 50 P(1, "four"), 51 P(2, "four"), 52 }; 53 C c0(a, a + sizeof(a)/sizeof(a[0]), 54 7, 55 test_hash<std::hash<int> >(8), 56 test_compare<std::equal_to<int> >(9), 57 A(10) 58 ); 59 C c(std::move(c0), A(12)); 60 assert(c.bucket_count() >= 7); 61 assert(c.size() == 6); 62 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 63 Eq eq = c.equal_range(1); 64 assert(std::distance(eq.first, eq.second) == 2); 65 C::const_iterator i = eq.first; 66 assert(i->first == 1); 67 assert(i->second == "one"); 68 ++i; 69 assert(i->first == 1); 70 assert(i->second == "four"); 71 eq = c.equal_range(2); 72 assert(std::distance(eq.first, eq.second) == 2); 73 i = eq.first; 74 assert(i->first == 2); 75 assert(i->second == "two"); 76 ++i; 77 assert(i->first == 2); 78 assert(i->second == "four"); 79 80 eq = c.equal_range(3); 81 assert(std::distance(eq.first, eq.second) == 1); 82 i = eq.first; 83 assert(i->first == 3); 84 assert(i->second == "three"); 85 eq = c.equal_range(4); 86 assert(std::distance(eq.first, eq.second) == 1); 87 i = eq.first; 88 assert(i->first == 4); 89 assert(i->second == "four"); 90 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 91 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 92 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 93 assert(c.max_load_factor() == 1); 94 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 95 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 96 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12))); 97 98 assert(c0.empty()); 99 } 100 { 101 typedef std::pair<int, std::string> P; 102 typedef test_allocator<std::pair<const int, std::string>> A; 103 typedef std::unordered_multimap<int, std::string, 104 test_hash<std::hash<int> >, 105 test_compare<std::equal_to<int> >, 106 A 107 > C; 108 P a[] = 109 { 110 P(1, "one"), 111 P(2, "two"), 112 P(3, "three"), 113 P(4, "four"), 114 P(1, "four"), 115 P(2, "four"), 116 }; 117 C c0(a, a + sizeof(a)/sizeof(a[0]), 118 7, 119 test_hash<std::hash<int> >(8), 120 test_compare<std::equal_to<int> >(9), 121 A(10) 122 ); 123 C c(std::move(c0), A(10)); 124 LIBCPP_ASSERT(c.bucket_count() == 7); 125 assert(c.size() == 6); 126 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 127 Eq eq = c.equal_range(1); 128 assert(std::distance(eq.first, eq.second) == 2); 129 C::const_iterator i = eq.first; 130 assert(i->first == 1); 131 assert(i->second == "one"); 132 ++i; 133 assert(i->first == 1); 134 assert(i->second == "four"); 135 eq = c.equal_range(2); 136 assert(std::distance(eq.first, eq.second) == 2); 137 i = eq.first; 138 assert(i->first == 2); 139 assert(i->second == "two"); 140 ++i; 141 assert(i->first == 2); 142 assert(i->second == "four"); 143 144 eq = c.equal_range(3); 145 assert(std::distance(eq.first, eq.second) == 1); 146 i = eq.first; 147 assert(i->first == 3); 148 assert(i->second == "three"); 149 eq = c.equal_range(4); 150 assert(std::distance(eq.first, eq.second) == 1); 151 i = eq.first; 152 assert(i->first == 4); 153 assert(i->second == "four"); 154 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 155 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 156 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 157 assert(c.max_load_factor() == 1); 158 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 159 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 160 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); 161 162 assert(c0.empty()); 163 } 164#if TEST_STD_VER >= 11 165 { 166 typedef std::pair<int, std::string> P; 167 typedef min_allocator<std::pair<const int, std::string>> A; 168 typedef std::unordered_multimap<int, std::string, 169 test_hash<std::hash<int> >, 170 test_compare<std::equal_to<int> >, 171 A 172 > C; 173 P a[] = 174 { 175 P(1, "one"), 176 P(2, "two"), 177 P(3, "three"), 178 P(4, "four"), 179 P(1, "four"), 180 P(2, "four"), 181 }; 182 C c0(a, a + sizeof(a)/sizeof(a[0]), 183 7, 184 test_hash<std::hash<int> >(8), 185 test_compare<std::equal_to<int> >(9), 186 A() 187 ); 188 C c(std::move(c0), A()); 189 LIBCPP_ASSERT(c.bucket_count() == 7); 190 assert(c.size() == 6); 191 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 192 Eq eq = c.equal_range(1); 193 assert(std::distance(eq.first, eq.second) == 2); 194 C::const_iterator i = eq.first; 195 assert(i->first == 1); 196 assert(i->second == "one"); 197 ++i; 198 assert(i->first == 1); 199 assert(i->second == "four"); 200 eq = c.equal_range(2); 201 assert(std::distance(eq.first, eq.second) == 2); 202 i = eq.first; 203 assert(i->first == 2); 204 assert(i->second == "two"); 205 ++i; 206 assert(i->first == 2); 207 assert(i->second == "four"); 208 209 eq = c.equal_range(3); 210 assert(std::distance(eq.first, eq.second) == 1); 211 i = eq.first; 212 assert(i->first == 3); 213 assert(i->second == "three"); 214 eq = c.equal_range(4); 215 assert(std::distance(eq.first, eq.second) == 1); 216 i = eq.first; 217 assert(i->first == 4); 218 assert(i->second == "four"); 219 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 220 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 221 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 222 assert(c.max_load_factor() == 1); 223 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 224 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 225 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); 226 227 assert(c0.empty()); 228 } 229 { 230 typedef std::pair<int, std::string> P; 231 typedef explicit_allocator<std::pair<const int, std::string>> A; 232 typedef std::unordered_multimap<int, std::string, 233 test_hash<std::hash<int> >, 234 test_compare<std::equal_to<int> >, 235 A 236 > C; 237 P a[] = 238 { 239 P(1, "one"), 240 P(2, "two"), 241 P(3, "three"), 242 P(4, "four"), 243 P(1, "four"), 244 P(2, "four"), 245 }; 246 C c0(a, a + sizeof(a)/sizeof(a[0]), 247 7, 248 test_hash<std::hash<int> >(8), 249 test_compare<std::equal_to<int> >(9), 250 A{} 251 ); 252 C c(std::move(c0), A()); 253 LIBCPP_ASSERT(c.bucket_count() == 7); 254 assert(c.size() == 6); 255 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 256 Eq eq = c.equal_range(1); 257 assert(std::distance(eq.first, eq.second) == 2); 258 C::const_iterator i = eq.first; 259 assert(i->first == 1); 260 assert(i->second == "one"); 261 ++i; 262 assert(i->first == 1); 263 assert(i->second == "four"); 264 eq = c.equal_range(2); 265 assert(std::distance(eq.first, eq.second) == 2); 266 i = eq.first; 267 assert(i->first == 2); 268 assert(i->second == "two"); 269 ++i; 270 assert(i->first == 2); 271 assert(i->second == "four"); 272 273 eq = c.equal_range(3); 274 assert(std::distance(eq.first, eq.second) == 1); 275 i = eq.first; 276 assert(i->first == 3); 277 assert(i->second == "three"); 278 eq = c.equal_range(4); 279 assert(std::distance(eq.first, eq.second) == 1); 280 i = eq.first; 281 assert(i->first == 4); 282 assert(i->second == "four"); 283 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 284 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 285 assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 286 assert(c.max_load_factor() == 1); 287 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 288 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 289 assert(c.get_allocator() == A{}); 290 291 assert(c0.empty()); 292 } 293#endif 294#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 295} 296