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