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// template <class InputIterator> 17// unordered_multimap(InputIterator first, InputIterator last); 18 19#include <unordered_map> 20#include <string> 21#include <cassert> 22#include <cfloat> 23#include <cstddef> 24 25#include "test_macros.h" 26#include "test_iterators.h" 27#include "../../../NotConstructible.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 { 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 P a[] = 43 { 44 P(1, "one"), 45 P(2, "two"), 46 P(3, "three"), 47 P(4, "four"), 48 P(1, "four"), 49 P(2, "four"), 50 }; 51 C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); 52 assert(c.bucket_count() >= 7); 53 assert(c.size() == 6); 54 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 55 Eq eq = c.equal_range(1); 56 assert(std::distance(eq.first, eq.second) == 2); 57 C::const_iterator i = eq.first; 58 assert(i->first == 1); 59 assert(i->second == "one"); 60 ++i; 61 assert(i->first == 1); 62 assert(i->second == "four"); 63 eq = c.equal_range(2); 64 assert(std::distance(eq.first, eq.second) == 2); 65 i = eq.first; 66 assert(i->first == 2); 67 assert(i->second == "two"); 68 ++i; 69 assert(i->first == 2); 70 assert(i->second == "four"); 71 72 eq = c.equal_range(3); 73 assert(std::distance(eq.first, eq.second) == 1); 74 i = eq.first; 75 assert(i->first == 3); 76 assert(i->second == "three"); 77 eq = c.equal_range(4); 78 assert(std::distance(eq.first, eq.second) == 1); 79 i = eq.first; 80 assert(i->first == 4); 81 assert(i->second == "four"); 82 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 83 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 84 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 85 assert(c.max_load_factor() == 1); 86 assert(c.hash_function() == test_hash<std::hash<int> >()); 87 assert(c.key_eq() == test_compare<std::equal_to<int> >()); 88 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); 89 } 90#if TEST_STD_VER >= 11 91 { 92 typedef std::unordered_multimap<int, std::string, 93 test_hash<std::hash<int> >, 94 test_compare<std::equal_to<int> >, 95 min_allocator<std::pair<const int, std::string> > 96 > C; 97 typedef std::pair<int, std::string> P; 98 P a[] = 99 { 100 P(1, "one"), 101 P(2, "two"), 102 P(3, "three"), 103 P(4, "four"), 104 P(1, "four"), 105 P(2, "four"), 106 }; 107 C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); 108 assert(c.bucket_count() >= 7); 109 assert(c.size() == 6); 110 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 111 Eq eq = c.equal_range(1); 112 assert(std::distance(eq.first, eq.second) == 2); 113 C::const_iterator i = eq.first; 114 assert(i->first == 1); 115 assert(i->second == "one"); 116 ++i; 117 assert(i->first == 1); 118 assert(i->second == "four"); 119 eq = c.equal_range(2); 120 assert(std::distance(eq.first, eq.second) == 2); 121 i = eq.first; 122 assert(i->first == 2); 123 assert(i->second == "two"); 124 ++i; 125 assert(i->first == 2); 126 assert(i->second == "four"); 127 128 eq = c.equal_range(3); 129 assert(std::distance(eq.first, eq.second) == 1); 130 i = eq.first; 131 assert(i->first == 3); 132 assert(i->second == "three"); 133 eq = c.equal_range(4); 134 assert(std::distance(eq.first, eq.second) == 1); 135 i = eq.first; 136 assert(i->first == 4); 137 assert(i->second == "four"); 138 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 139 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 140 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 141 assert(c.max_load_factor() == 1); 142 assert(c.hash_function() == test_hash<std::hash<int> >()); 143 assert(c.key_eq() == test_compare<std::equal_to<int> >()); 144 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); 145 } 146#if TEST_STD_VER > 11 147 { 148 typedef std::pair<int, std::string> P; 149 typedef test_allocator<std::pair<const int, std::string>> A; 150 typedef test_hash<std::hash<int>> HF; 151 typedef test_compare<std::equal_to<int>> Comp; 152 typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; 153 154 P arr[] = 155 { 156 P(1, "one"), 157 P(2, "two"), 158 P(3, "three"), 159 P(4, "four"), 160 P(1, "four"), 161 P(2, "four"), 162 }; 163 A a(42); 164 C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a); 165 assert(c.bucket_count() >= 14); 166 assert(c.size() == 6); 167 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 168 Eq eq = c.equal_range(1); 169 assert(std::distance(eq.first, eq.second) == 2); 170 C::const_iterator i = eq.first; 171 assert(i->first == 1); 172 assert(i->second == "one"); 173 ++i; 174 assert(i->first == 1); 175 assert(i->second == "four"); 176 eq = c.equal_range(2); 177 assert(std::distance(eq.first, eq.second) == 2); 178 i = eq.first; 179 assert(i->first == 2); 180 assert(i->second == "two"); 181 ++i; 182 assert(i->first == 2); 183 assert(i->second == "four"); 184 185 eq = c.equal_range(3); 186 assert(std::distance(eq.first, eq.second) == 1); 187 i = eq.first; 188 assert(i->first == 3); 189 assert(i->second == "three"); 190 eq = c.equal_range(4); 191 assert(std::distance(eq.first, eq.second) == 1); 192 i = eq.first; 193 assert(i->first == 4); 194 assert(i->second == "four"); 195 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 196 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 197 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 198 assert(c.max_load_factor() == 1); 199 assert(c.hash_function() == HF()); 200 assert(c.key_eq() == Comp()); 201 assert(c.get_allocator() == a); 202 assert(!(c.get_allocator() == A())); 203 } 204 { 205 typedef std::pair<int, std::string> P; 206 typedef test_allocator<std::pair<const int, std::string>> A; 207 typedef test_hash<std::hash<int>> HF; 208 typedef test_compare<std::equal_to<int>> Comp; 209 typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; 210 211 P arr[] = 212 { 213 P(1, "one"), 214 P(2, "two"), 215 P(3, "three"), 216 P(4, "four"), 217 P(1, "four"), 218 P(2, "four"), 219 }; 220 A a(42); 221 HF hf (43); 222 C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a ); 223 assert(c.bucket_count() >= 12); 224 assert(c.size() == 6); 225 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 226 Eq eq = c.equal_range(1); 227 assert(std::distance(eq.first, eq.second) == 2); 228 C::const_iterator i = eq.first; 229 assert(i->first == 1); 230 assert(i->second == "one"); 231 ++i; 232 assert(i->first == 1); 233 assert(i->second == "four"); 234 eq = c.equal_range(2); 235 assert(std::distance(eq.first, eq.second) == 2); 236 i = eq.first; 237 assert(i->first == 2); 238 assert(i->second == "two"); 239 ++i; 240 assert(i->first == 2); 241 assert(i->second == "four"); 242 243 eq = c.equal_range(3); 244 assert(std::distance(eq.first, eq.second) == 1); 245 i = eq.first; 246 assert(i->first == 3); 247 assert(i->second == "three"); 248 eq = c.equal_range(4); 249 assert(std::distance(eq.first, eq.second) == 1); 250 i = eq.first; 251 assert(i->first == 4); 252 assert(i->second == "four"); 253 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 254 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 255 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 256 assert(c.max_load_factor() == 1); 257 assert(c.hash_function() == hf); 258 assert(!(c.hash_function() == HF())); 259 assert(c.key_eq() == Comp()); 260 assert(c.get_allocator() == a); 261 assert(!(c.get_allocator() == A())); 262 } 263#endif 264#endif 265} 266