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 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 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
}
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;
}
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
}
