int main() { { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() == 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i = c.begin(); assert(*i == 1); *i = 2; } { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() == 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); } }
int main() { { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #if __cplusplus >= 201103L { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #endif #if _LIBCPP_STD_VER > 11 { // N3644 testing typedef std::unordered_map<int,double> C; C::iterator ii1{}, ii2{}; C::iterator ii4 = ii1; C::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert ( ii1 == cii ); assert ( !(ii1 != ii2 )); assert ( !(ii1 != cii )); } #endif }
int tc_libcxx_containers_unord_map_local_iterators(void) { { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); TC_ASSERT_EXPR(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 1); TC_ASSERT_EXPR(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 2); TC_ASSERT_EXPR(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 3); TC_ASSERT_EXPR(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 4); TC_ASSERT_EXPR(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); TC_ASSERT_EXPR(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 1); TC_ASSERT_EXPR(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 2); TC_ASSERT_EXPR(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 3); TC_ASSERT_EXPR(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 4); TC_ASSERT_EXPR(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); TC_ASSERT_EXPR(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 1); TC_ASSERT_EXPR(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 2); TC_ASSERT_EXPR(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 3); TC_ASSERT_EXPR(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 4); TC_ASSERT_EXPR(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); TC_ASSERT_EXPR(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 1); TC_ASSERT_EXPR(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 2); TC_ASSERT_EXPR(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 3); TC_ASSERT_EXPR(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); TC_ASSERT_EXPR(std::distance(i, j) == 1); TC_ASSERT_EXPR(i->first == 4); TC_ASSERT_EXPR(i->second == "four"); } TC_SUCCESS_RESULT(); return 0; }
int main() { { typedef std::unordered_set<int> C; typedef int P; typedef C::local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } }
int main() { { typedef int T; typedef std::vector<T> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::vector<T> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::vector<T> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef int T; typedef std::vector<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.begin(); assert(*i == 0); ++i; assert(*i == 1); *i = 10; assert(*i == 10); assert(std::distance(c.begin(), c.end()) == 10); } { typedef int T; typedef std::vector<T> C; C::iterator i; C::const_iterator j; } #if TEST_STD_VER >= 11 { typedef int T; typedef std::vector<T, min_allocator<T>> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::vector<T, min_allocator<T>> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::vector<T, min_allocator<T>> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef int T; typedef std::vector<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.begin(); assert(*i == 0); ++i; assert(*i == 1); *i = 10; assert(*i == 10); assert(std::distance(c.begin(), c.end()) == 10); } { typedef int T; typedef std::vector<T, min_allocator<T>> C; C::iterator i; C::const_iterator j; } { typedef A T; typedef std::vector<T, min_allocator<T>> C; C c = {A{1, 2}}; C::iterator i = c.begin(); i->first = 3; C::const_iterator j = i; assert(j->first == 3); } #endif #if _LIBCPP_STD_VER > 11 { // N3644 testing typedef std::vector<int> C; C::iterator ii1{}, ii2{}; C::iterator ii4 = ii1; C::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert (!(ii1 != ii2 )); assert ( (ii1 == cii )); assert ( (cii == ii1 )); assert (!(ii1 != cii )); assert (!(cii != ii1 )); assert (!(ii1 < cii )); assert (!(cii < ii1 )); assert ( (ii1 <= cii )); assert ( (cii <= ii1 )); assert (!(ii1 > cii )); assert (!(cii > ii1 )); assert ( (ii1 >= cii )); assert ( (cii >= ii1 )); assert (cii - ii1 == 0); assert (ii1 - cii == 0); } #endif }
C m( { {1, 1}, {1, 1.5}, {1, 2}, {2, 1}, {2, 1.5}, {2, 2}, {3, 1}, {3, 1.5}, {3, 2} }, Cmp(4), A(5) ); REQUIRE(m.size() == 9); REQUIRE(distance(m.begin(), m.end()) == 9); C::const_iterator i = m.cbegin(); REQUIRE(*i == V(1, 1)); REQUIRE(*++i == V(1, 1.5)); REQUIRE(*++i == V(1, 2)); REQUIRE(*++i == V(2, 1)); REQUIRE(*++i == V(2, 1.5)); REQUIRE(*++i == V(2, 2)); REQUIRE(*++i == V(3, 1)); REQUIRE(*++i == V(3, 1.5)); REQUIRE(*++i == V(3, 2)); REQUIRE(m.key_comp() == Cmp(4)); REQUIRE(m.get_allocator() == A(5)); } #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #if TEST_STD_VER >= 11
void main() { { typedef unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); ///assert(c.bucket_count() >= 7); assert(c.size() == 6); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; i = c.begin(); i->second = "ONE"; assert(i->second == "ONE"); } { typedef unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); ///assert(c.bucket_count() >= 7); assert(c.size() == 6); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; i = c.begin(); i->second = "ONE"; assert(i->second == "ONE"); } { typedef unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #endif //#if _LIBCPP_STD_VER > 11 { // N3644 testing typedef unordered_multimap<int,double> C; C::iterator ii1{}, ii2{}; C::iterator ii4 = ii1; C::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert (!(ii1 != ii2 )); assert ( (ii1 == cii )); assert ( (cii == ii1 )); assert (!(ii1 != cii )); assert (!(cii != ii1 )); } //#endif }
int main() { { typedef bool T; typedef std::vector<T> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef bool T; typedef std::vector<T> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef bool T; typedef std::vector<T> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef bool T; typedef std::vector<T> C; C::iterator i; C::const_iterator j; } #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { typedef bool T; typedef std::vector<T, min_allocator<T>> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef bool T; typedef std::vector<T, min_allocator<T>> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef bool T; typedef std::vector<T, min_allocator<T>> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef bool T; typedef std::vector<T, min_allocator<T>> C; C::iterator i; C::const_iterator j; } #endif #if _LIBCPP_STD_VER > 11 { // N3644 testing std::vector<bool>::iterator ii1{}, ii2{}; std::vector<bool>::iterator ii4 = ii1; std::vector<bool>::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert (!(ii1 != ii2 )); assert ( (ii1 == cii )); assert ( (cii == ii1 )); assert (!(ii1 != cii )); assert (!(cii != ii1 )); assert (!(ii1 < cii )); assert (!(cii < ii1 )); assert ( (ii1 <= cii )); assert ( (cii <= ii1 )); assert (!(ii1 > cii )); assert (!(cii > ii1 )); assert ( (ii1 >= cii )); assert ( (cii >= ii1 )); assert (cii - ii1 == 0); assert (ii1 - cii == 0); } #endif }
int main() { { typedef int T; typedef std::forward_list<T> C; C c; C::iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 1); } { typedef int T; typedef std::forward_list<T> C; const C c; C::const_iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 1); } { typedef int T; typedef std::forward_list<T> C; const C c; C::const_iterator i = c.cbefore_begin(); assert(std::distance(i, c.end()) == 1); assert(c.cbefore_begin() == c.before_begin()); } { typedef int T; typedef std::forward_list<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 11); assert(std::next(c.before_begin()) == c.begin()); } { typedef int T; typedef std::forward_list<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const C c(std::begin(t), std::end(t)); C::const_iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 11); } #if TEST_STD_VER >= 11 { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; C c; C::iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 1); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const C c; C::const_iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 1); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const C c; C::const_iterator i = c.cbefore_begin(); assert(std::distance(i, c.end()) == 1); assert(c.cbefore_begin() == c.before_begin()); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 11); assert(std::next(c.before_begin()) == c.begin()); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const C c(std::begin(t), std::end(t)); C::const_iterator i = c.before_begin(); assert(std::distance(i, c.end()) == 11); } #endif }
int main() { { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } #if TEST_STD_VER >= 11 { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; typedef C::local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 1); assert(i->second == "one"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 2); assert(i->second == "two"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); } #endif }
void main() { { typedef unordered_set<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef unordered_set<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); assert(c.size() == 4); assert((size_t)std::distance(c.begin(), c.end()) == c.size()); assert((size_t)std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #endif //#if _LIBCPP_STD_VER > 11 { // N3644 testing typedef unordered_set<int> C; C::iterator ii1{}, ii2{}; C::iterator ii4 = ii1; C::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert (!(ii1 != ii2 )); assert ( (ii1 == cii )); assert ( (cii == ii1 )); assert (!(ii1 != cii )); assert (!(cii != ii1 )); } //#endif }
int tc_libcxx_containers_vector_bool_iterators(void) { { typedef bool T; typedef std::vector<T> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); TC_ASSERT_EXPR(std::distance(i, j) == 0); TC_ASSERT_EXPR(i == j); } { typedef bool T; typedef std::vector<T> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); TC_ASSERT_EXPR(std::distance(i, j) == 0); TC_ASSERT_EXPR(i == j); } { typedef bool T; typedef std::vector<T> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); TC_ASSERT_EXPR(std::distance(i, j) == 0); TC_ASSERT_EXPR(i == j); TC_ASSERT_EXPR(i == c.end()); } { typedef bool T; typedef std::vector<T> C; C::iterator i; C::const_iterator j; } #if TEST_STD_VER > 11 { // N3644 testing std::vector<bool>::iterator ii1{}, ii2{}; std::vector<bool>::iterator ii4 = ii1; std::vector<bool>::const_iterator cii{}; TC_ASSERT_EXPR ( ii1 == ii2 ); TC_ASSERT_EXPR ( ii1 == ii4 ); TC_ASSERT_EXPR (!(ii1 != ii2 )); TC_ASSERT_EXPR ( (ii1 == cii )); TC_ASSERT_EXPR ( (cii == ii1 )); TC_ASSERT_EXPR (!(ii1 != cii )); TC_ASSERT_EXPR (!(cii != ii1 )); TC_ASSERT_EXPR (!(ii1 < cii )); TC_ASSERT_EXPR (!(cii < ii1 )); TC_ASSERT_EXPR ( (ii1 <= cii )); TC_ASSERT_EXPR ( (cii <= ii1 )); TC_ASSERT_EXPR (!(ii1 > cii )); TC_ASSERT_EXPR (!(cii > ii1 )); TC_ASSERT_EXPR ( (ii1 >= cii )); TC_ASSERT_EXPR ( (cii >= ii1 )); TC_ASSERT_EXPR (cii - ii1 == 0); TC_ASSERT_EXPR (ii1 - cii == 0); } #endif TC_SUCCESS_RESULT(); return 0; }
int main(int, char**) { { typedef std::unordered_set<int> C; typedef int P; typedef C::local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } #if TEST_STD_VER >= 11 { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } #endif return 0; }
int main(int, char**) { { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); LIBCPP_ASSERT(c.bucket_count() == 7); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 2); assert(i->first == 1); assert(i->second == "one"); ++i; assert(i->first == 1); assert(i->second == "four"); i->first = 2; b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 2); assert(i->first == 2); assert(i->second == "two"); ++i; assert(i->first == 2); assert(i->second == "four"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); b = c.bucket(5); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(6); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 0); } { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); LIBCPP_ASSERT(c.bucket_count() == 7); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 2); assert(i->first == 1); assert(i->second == "one"); ++i; assert(i->first == 1); assert(i->second == "four"); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 2); assert(i->first == 2); assert(i->second == "two"); ++i; assert(i->first == 2); assert(i->second == "four"); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); b = c.bucket(5); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(6); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 0); } { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; C c(a, a + sizeof(a)/sizeof(a[0])); LIBCPP_ASSERT(c.bucket_count() == 7); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 2); assert(i->first == 1); assert(i->second == "one"); ++i; assert(i->first == 1); assert(i->second == "four"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 2); assert(i->first == 2); assert(i->second == "two"); ++i; assert(i->first == 2); assert(i->second == "four"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); b = c.bucket(5); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(6); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 0); } { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; typedef C::const_local_iterator I; P a[] = { P(1, "one"), P(2, "two"), P(3, "three"), P(4, "four"), P(1, "four"), P(2, "four"), }; const C c(a, a + sizeof(a)/sizeof(a[0])); LIBCPP_ASSERT(c.bucket_count() == 7); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 2); assert(i->first == 1); assert(i->second == "one"); ++i; assert(i->first == 1); assert(i->second == "four"); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 2); assert(i->first == 2); assert(i->second == "two"); ++i; assert(i->first == 2); assert(i->second == "four"); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 3); assert(i->second == "three"); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(i->first == 4); assert(i->second == "four"); b = c.bucket(5); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(6); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 0); } return 0; }
int main() { { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #if __cplusplus >= 201103L { typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i; } { typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::const_iterator i; } #endif #if _LIBCPP_STD_VER > 11 { // N3644 testing typedef std::unordered_multiset<int> C; C::iterator ii1{}, ii2{}; C::iterator ii4 = ii1; C::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert ( ii1 == cii ); assert ( !(ii1 != ii2 )); assert ( !(ii1 != cii )); } #endif }
int main(int, char**) { { typedef int T; typedef std::forward_list<T> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::forward_list<T> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::forward_list<T> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef int T; typedef std::forward_list<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.begin(); assert(*i == 0); ++i; assert(*i == 1); *i = 10; assert(*i == 10); assert(std::distance(c.begin(), c.end()) == 10); } { typedef int T; typedef std::forward_list<T> C; C::iterator i; C::const_iterator j; } #if TEST_STD_VER >= 11 { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; C c; C::iterator i = c.begin(); C::iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const C c; C::const_iterator i = c.begin(); C::const_iterator j = c.end(); assert(std::distance(i, j) == 0); assert(i == j); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; C c; C::const_iterator i = c.cbegin(); C::const_iterator j = c.cend(); assert(std::distance(i, j) == 0); assert(i == j); assert(i == c.end()); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); C::iterator i = c.begin(); assert(*i == 0); ++i; assert(*i == 1); *i = 10; assert(*i == 10); assert(std::distance(c.begin(), c.end()) == 10); } { typedef int T; typedef std::forward_list<T, min_allocator<T>> C; C::iterator i; C::const_iterator j; } #endif #if TEST_STD_VER > 11 { // N3644 testing std::forward_list<int>::iterator ii1{}, ii2{}; std::forward_list<int>::iterator ii4 = ii1; std::forward_list<int>::const_iterator cii{}; assert ( ii1 == ii2 ); assert ( ii1 == ii4 ); assert (!(ii1 != ii2 )); assert ( (ii1 == cii )); assert ( (cii == ii1 )); assert (!(ii1 != cii )); assert (!(cii != ii1 )); // std::forward_list<int> c; // assert ( ii1 != c.cbegin()); // assert ( cii != c.begin()); // assert ( cii != c.cend()); // assert ( ii1 != c.end()); } #endif return 0; }
void main() { { typedef unordered_set<int> C; typedef int P; typedef C::local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.begin(b); I j = c.end(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.begin(b); j = c.end(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; typedef C::const_local_iterator I; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() >= 5); C::size_type b = c.bucket(0); I i = c.cbegin(b); I j = c.cend(b); assert(std::distance(i, j) == 0); b = c.bucket(1); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 1); b = c.bucket(2); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 2); b = c.bucket(3); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 3); b = c.bucket(4); i = c.cbegin(b); j = c.cend(b); assert(std::distance(i, j) == 1); assert(*i == 4); } #endif }