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& operator=(const unordered_multimap& u); 17 18#include <unordered_map> 19#include <string> 20#include <cassert> 21#include <cfloat> 22#include <cstddef> 23 24#include "test_macros.h" 25#include "../../../test_compare.h" 26#include "../../../test_hash.h" 27#include "test_allocator.h" 28#include "min_allocator.h" 29 30int main() 31{ 32 { 33 typedef test_allocator<std::pair<const int, std::string> > A; 34 typedef std::unordered_multimap<int, std::string, 35 test_hash<std::hash<int> >, 36 test_compare<std::equal_to<int> >, 37 A 38 > C; 39 typedef std::pair<int, std::string> P; 40 P a[] = 41 { 42 P(1, "one"), 43 P(2, "two"), 44 P(3, "three"), 45 P(4, "four"), 46 P(1, "four"), 47 P(2, "four"), 48 }; 49 C c0(a, a + sizeof(a)/sizeof(a[0]), 50 7, 51 test_hash<std::hash<int> >(8), 52 test_compare<std::equal_to<int> >(9), 53 A(10) 54 ); 55 C c(a, a + 2, 56 7, 57 test_hash<std::hash<int> >(2), 58 test_compare<std::equal_to<int> >(3), 59 A(4) 60 ); 61 c = c0; 62 LIBCPP_ASSERT(c.bucket_count() == 7); 63 assert(c.size() == 6); 64 C::const_iterator i = c.cbegin(); 65 assert(i->first == 1); 66 assert(i->second == "one"); 67 ++i; 68 assert(i->first == 1); 69 assert(i->second == "four"); 70 ++i; 71 assert(i->first == 2); 72 assert(i->second == "two"); 73 ++i; 74 assert(i->first == 2); 75 assert(i->second == "four"); 76 ++i; 77 assert(i->first == 3); 78 assert(i->second == "three"); 79 ++i; 80 assert(i->first == 4); 81 assert(i->second == "four"); 82 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 83 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 84 assert(c.get_allocator() == A(4)); 85 assert(!c.empty()); 86 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 87 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 88 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 89 assert(c.max_load_factor() == 1); 90 } 91 { 92 typedef std::unordered_multimap<int, std::string> C; 93 typedef std::pair<const int, std::string> P; 94 const P a[] = 95 { 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 C c(a, a+sizeof(a)/sizeof(a[0])); 104 C *p = &c; 105 c = *p; 106 assert(c.size() == 6); 107 assert(std::is_permutation(c.begin(), c.end(), a)); 108 } 109 { 110 typedef other_allocator<std::pair<const int, std::string> > A; 111 typedef std::unordered_multimap<int, std::string, 112 test_hash<std::hash<int> >, 113 test_compare<std::equal_to<int> >, 114 A 115 > C; 116 typedef std::pair<int, std::string> P; 117 P a[] = 118 { 119 P(1, "one"), 120 P(2, "two"), 121 P(3, "three"), 122 P(4, "four"), 123 P(1, "four"), 124 P(2, "four"), 125 }; 126 C c0(a, a + sizeof(a)/sizeof(a[0]), 127 7, 128 test_hash<std::hash<int> >(8), 129 test_compare<std::equal_to<int> >(9), 130 A(10) 131 ); 132 C c(a, a + 2, 133 7, 134 test_hash<std::hash<int> >(2), 135 test_compare<std::equal_to<int> >(3), 136 A(4) 137 ); 138 c = c0; 139 assert(c.bucket_count() >= 7); 140 assert(c.size() == 6); 141 C::const_iterator i = c.cbegin(); 142 assert(i->first == 1); 143 assert(i->second == "one"); 144 ++i; 145 assert(i->first == 1); 146 assert(i->second == "four"); 147 ++i; 148 assert(i->first == 2); 149 assert(i->second == "two"); 150 ++i; 151 assert(i->first == 2); 152 assert(i->second == "four"); 153 ++i; 154 assert(i->first == 3); 155 assert(i->second == "three"); 156 ++i; 157 assert(i->first == 4); 158 assert(i->second == "four"); 159 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 160 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 161 assert(c.get_allocator() == A(10)); 162 assert(!c.empty()); 163 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 164 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 165 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 166 assert(c.max_load_factor() == 1); 167 } 168#if TEST_STD_VER >= 11 169 { 170 typedef min_allocator<std::pair<const int, std::string> > A; 171 typedef std::unordered_multimap<int, std::string, 172 test_hash<std::hash<int> >, 173 test_compare<std::equal_to<int> >, 174 A 175 > C; 176 typedef std::pair<int, std::string> P; 177 P a[] = 178 { 179 P(1, "one"), 180 P(2, "two"), 181 P(3, "three"), 182 P(4, "four"), 183 P(1, "four"), 184 P(2, "four"), 185 }; 186 C c0(a, a + sizeof(a)/sizeof(a[0]), 187 7, 188 test_hash<std::hash<int> >(8), 189 test_compare<std::equal_to<int> >(9), 190 A() 191 ); 192 C c(a, a + 2, 193 7, 194 test_hash<std::hash<int> >(2), 195 test_compare<std::equal_to<int> >(3), 196 A() 197 ); 198 c = c0; 199 LIBCPP_ASSERT(c.bucket_count() == 7); 200 assert(c.size() == 6); 201 C::const_iterator i = c.cbegin(); 202 assert(i->first == 1); 203 assert(i->second == "one"); 204 ++i; 205 assert(i->first == 1); 206 assert(i->second == "four"); 207 ++i; 208 assert(i->first == 2); 209 assert(i->second == "two"); 210 ++i; 211 assert(i->first == 2); 212 assert(i->second == "four"); 213 ++i; 214 assert(i->first == 3); 215 assert(i->second == "three"); 216 ++i; 217 assert(i->first == 4); 218 assert(i->second == "four"); 219 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 220 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 221 assert(c.get_allocator() == A()); 222 assert(!c.empty()); 223 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 224 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 225 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 226 assert(c.max_load_factor() == 1); 227 } 228#endif 229} 230