local_iterators.fail.cpp (7772B)
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 // local_iterator begin (size_type n); 17 // local_iterator end (size_type n); 18 // const_local_iterator begin (size_type n) const; 19 // const_local_iterator end (size_type n) const; 20 // const_local_iterator cbegin(size_type n) const; 21 // const_local_iterator cend (size_type n) const; 22 23 #include <unordered_map> 24 #include <string> 25 #include <cassert> 26 27 #include "test_macros.h" 28 29 int main() 30 { 31 { 32 typedef std::unordered_multimap<int, std::string> C; 33 typedef std::pair<int, std::string> P; 34 typedef C::local_iterator I; 35 P a[] = 36 { 37 P(1, "one"), 38 P(2, "two"), 39 P(3, "three"), 40 P(4, "four"), 41 P(1, "four"), 42 P(2, "four"), 43 }; 44 C c(a, a + sizeof(a)/sizeof(a[0])); 45 LIBCPP_ASSERT(c.bucket_count() == 7); 46 C::size_type b = c.bucket(0); 47 I i = c.begin(b); 48 I j = c.end(b); 49 assert(std::distance(i, j) == 0); 50 51 b = c.bucket(1); 52 i = c.begin(b); 53 j = c.end(b); 54 assert(std::distance(i, j) == 2); 55 assert(i->first == 1); 56 assert(i->second == "one"); 57 ++i; 58 assert(i->first == 1); 59 assert(i->second == "four"); 60 i->first = 2; 61 62 b = c.bucket(2); 63 i = c.begin(b); 64 j = c.end(b); 65 assert(std::distance(i, j) == 2); 66 assert(i->first == 2); 67 assert(i->second == "two"); 68 ++i; 69 assert(i->first == 2); 70 assert(i->second == "four"); 71 72 b = c.bucket(3); 73 i = c.begin(b); 74 j = c.end(b); 75 assert(std::distance(i, j) == 1); 76 assert(i->first == 3); 77 assert(i->second == "three"); 78 79 b = c.bucket(4); 80 i = c.begin(b); 81 j = c.end(b); 82 assert(std::distance(i, j) == 1); 83 assert(i->first == 4); 84 assert(i->second == "four"); 85 86 b = c.bucket(5); 87 i = c.begin(b); 88 j = c.end(b); 89 assert(std::distance(i, j) == 0); 90 91 b = c.bucket(6); 92 i = c.begin(b); 93 j = c.end(b); 94 assert(std::distance(i, j) == 0); 95 } 96 { 97 typedef std::unordered_multimap<int, std::string> C; 98 typedef std::pair<int, std::string> P; 99 typedef C::const_local_iterator I; 100 P a[] = 101 { 102 P(1, "one"), 103 P(2, "two"), 104 P(3, "three"), 105 P(4, "four"), 106 P(1, "four"), 107 P(2, "four"), 108 }; 109 const C c(a, a + sizeof(a)/sizeof(a[0])); 110 LIBCPP_ASSERT(c.bucket_count() == 7); 111 C::size_type b = c.bucket(0); 112 I i = c.begin(b); 113 I j = c.end(b); 114 assert(std::distance(i, j) == 0); 115 116 b = c.bucket(1); 117 i = c.begin(b); 118 j = c.end(b); 119 assert(std::distance(i, j) == 2); 120 assert(i->first == 1); 121 assert(i->second == "one"); 122 ++i; 123 assert(i->first == 1); 124 assert(i->second == "four"); 125 126 b = c.bucket(2); 127 i = c.begin(b); 128 j = c.end(b); 129 assert(std::distance(i, j) == 2); 130 assert(i->first == 2); 131 assert(i->second == "two"); 132 ++i; 133 assert(i->first == 2); 134 assert(i->second == "four"); 135 136 b = c.bucket(3); 137 i = c.begin(b); 138 j = c.end(b); 139 assert(std::distance(i, j) == 1); 140 assert(i->first == 3); 141 assert(i->second == "three"); 142 143 b = c.bucket(4); 144 i = c.begin(b); 145 j = c.end(b); 146 assert(std::distance(i, j) == 1); 147 assert(i->first == 4); 148 assert(i->second == "four"); 149 150 b = c.bucket(5); 151 i = c.begin(b); 152 j = c.end(b); 153 assert(std::distance(i, j) == 0); 154 155 b = c.bucket(6); 156 i = c.begin(b); 157 j = c.end(b); 158 assert(std::distance(i, j) == 0); 159 } 160 { 161 typedef std::unordered_multimap<int, std::string> C; 162 typedef std::pair<int, std::string> P; 163 typedef C::const_local_iterator I; 164 P a[] = 165 { 166 P(1, "one"), 167 P(2, "two"), 168 P(3, "three"), 169 P(4, "four"), 170 P(1, "four"), 171 P(2, "four"), 172 }; 173 C c(a, a + sizeof(a)/sizeof(a[0])); 174 LIBCPP_ASSERT(c.bucket_count() == 7); 175 C::size_type b = c.bucket(0); 176 I i = c.cbegin(b); 177 I j = c.cend(b); 178 assert(std::distance(i, j) == 0); 179 180 b = c.bucket(1); 181 i = c.cbegin(b); 182 j = c.cend(b); 183 assert(std::distance(i, j) == 2); 184 assert(i->first == 1); 185 assert(i->second == "one"); 186 ++i; 187 assert(i->first == 1); 188 assert(i->second == "four"); 189 190 b = c.bucket(2); 191 i = c.cbegin(b); 192 j = c.cend(b); 193 assert(std::distance(i, j) == 2); 194 assert(i->first == 2); 195 assert(i->second == "two"); 196 ++i; 197 assert(i->first == 2); 198 assert(i->second == "four"); 199 200 b = c.bucket(3); 201 i = c.cbegin(b); 202 j = c.cend(b); 203 assert(std::distance(i, j) == 1); 204 assert(i->first == 3); 205 assert(i->second == "three"); 206 207 b = c.bucket(4); 208 i = c.cbegin(b); 209 j = c.cend(b); 210 assert(std::distance(i, j) == 1); 211 assert(i->first == 4); 212 assert(i->second == "four"); 213 214 b = c.bucket(5); 215 i = c.cbegin(b); 216 j = c.cend(b); 217 assert(std::distance(i, j) == 0); 218 219 b = c.bucket(6); 220 i = c.cbegin(b); 221 j = c.cend(b); 222 assert(std::distance(i, j) == 0); 223 } 224 { 225 typedef std::unordered_multimap<int, std::string> C; 226 typedef std::pair<int, std::string> P; 227 typedef C::const_local_iterator I; 228 P a[] = 229 { 230 P(1, "one"), 231 P(2, "two"), 232 P(3, "three"), 233 P(4, "four"), 234 P(1, "four"), 235 P(2, "four"), 236 }; 237 const C c(a, a + sizeof(a)/sizeof(a[0])); 238 LIBCPP_ASSERT(c.bucket_count() == 7); 239 C::size_type b = c.bucket(0); 240 I i = c.cbegin(b); 241 I j = c.cend(b); 242 assert(std::distance(i, j) == 0); 243 244 b = c.bucket(1); 245 i = c.cbegin(b); 246 j = c.cend(b); 247 assert(std::distance(i, j) == 2); 248 assert(i->first == 1); 249 assert(i->second == "one"); 250 ++i; 251 assert(i->first == 1); 252 assert(i->second == "four"); 253 254 b = c.bucket(2); 255 i = c.cbegin(b); 256 j = c.cend(b); 257 assert(std::distance(i, j) == 2); 258 assert(i->first == 2); 259 assert(i->second == "two"); 260 ++i; 261 assert(i->first == 2); 262 assert(i->second == "four"); 263 264 b = c.bucket(3); 265 i = c.cbegin(b); 266 j = c.cend(b); 267 assert(std::distance(i, j) == 1); 268 assert(i->first == 3); 269 assert(i->second == "three"); 270 271 b = c.bucket(4); 272 i = c.cbegin(b); 273 j = c.cend(b); 274 assert(std::distance(i, j) == 1); 275 assert(i->first == 4); 276 assert(i->second == "four"); 277 278 b = c.bucket(5); 279 i = c.cbegin(b); 280 j = c.cend(b); 281 assert(std::distance(i, j) == 0); 282 283 b = c.bucket(6); 284 i = c.cbegin(b); 285 j = c.cend(b); 286 assert(std::distance(i, j) == 0); 287 } 288 }