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