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