static int
test(typename C::size_type n, const typename C::value_type& x,
const typename C::allocator_type& a)
{
C c(n, x, a);
LIBCPP_ASSERT(c.__invariants());
TC_ASSERT_EXPR(a == c.get_allocator());
TC_ASSERT_EXPR(c.size() == n);
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
TC_ASSERT_EXPR(*i == x);
return 0;
}
void
test_exceptions(S s, It first, It last)
{
S aCopy = s;
try {
s.append(first, last);
assert(false);
}
catch (...) {}
LIBCPP_ASSERT(s.__invariants());
assert(s == aCopy);
}
static int
test(S s, typename S::difference_type pos, typename S::difference_type n, S expected)
{
typename S::const_iterator first = s.cbegin() + pos;
typename S::const_iterator last = s.cbegin() + pos + n;
typename S::iterator i = s.erase(first, last);
LIBCPP_ASSERT(s.__invariants());
TC_ASSERT_EXPR(s[s.size()] == typename S::value_type());
TC_ASSERT_EXPR(s == expected);
TC_ASSERT_EXPR(i - s.begin() == pos);
return 0;
}
void
test(const charT* s, unsigned n)
{
typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
typedef typename S::traits_type T;
typedef typename S::allocator_type A;
S s2(s, n);
LIBCPP_ASSERT(s2.__invariants());
assert(s2.size() == n);
assert(T::compare(s2.data(), s, n) == 0);
assert(s2.get_allocator() == A());
assert(s2.capacity() >= s2.size());
}
int main()
{
{
typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible>
> C;
C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
{
typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible>
> C;
C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#endif
}
void
test(const charT* s, const A& a)
{
typedef std::basic_string<charT, std::char_traits<charT>, A> S;
typedef typename S::traits_type T;
std::size_t n = T::length(s);
S s2(s, a);
LIBCPP_ASSERT(s2.__invariants());
assert(s2.size() == n);
assert(T::compare(s2.data(), s, n) == 0);
assert(s2.get_allocator() == a);
assert(s2.capacity() >= s2.size());
}
int main()
{
// The default launch policy is implementation defined. libc++ defines
// it to be std::launch::async.
bool DefaultPolicyIsDeferred = false;
bool DPID = DefaultPolicyIsDeferred;
std::launch AnyPolicy = std::launch::async | std::launch::deferred;
LIBCPP_ASSERT(AnyPolicy == std::launch::any);
{
auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
test<int>(checkInt, DPID, f0);
test<int>(checkInt, false, std::launch::async, f0);
test<int>(checkInt, true, std::launch::deferred, f0);
test<int>(checkInt, DPID, AnyPolicy, f0);
}
{
auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
test<int&>(checkIntRef, DPID, f1);
test<int&>(checkIntRef, false, std::launch::async, f1);
test<int&>(checkIntRef, true, std::launch::deferred, f1);
test<int&>(checkIntRef, DPID, AnyPolicy, f1);
}
{
auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
test<void>(checkVoid, DPID, f2);
test<void>(checkVoid, false, std::launch::async, f2);
test<void>(checkVoid, true, std::launch::deferred, f2);
test<void>(checkVoid, DPID, AnyPolicy, f2);
}
{
using Ret = std::unique_ptr<int>;
auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
test<Ret>(checkUPtr, DPID, f3, 3);
test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::future<void> f = std::async(f5, 3);
std::this_thread::sleep_for(ms(300));
try { f.get(); assert (false); } catch ( int ) {}
}
{
std::future<void> f = std::async(std::launch::deferred, f5, 3);
std::this_thread::sleep_for(ms(300));
try { f.get(); assert (false); } catch ( int ) {}
}
#endif
}
void
test(std::basic_string_view<charT> sv, const A& a)
{
typedef std::basic_string<charT, std::char_traits<charT>, A> S;
typedef typename S::traits_type T;
{
S s2(sv, a);
LIBCPP_ASSERT(s2.__invariants());
assert(s2.size() == sv.size());
assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
assert(s2.get_allocator() == a);
assert(s2.capacity() >= s2.size());
}
{
S s2(a);
s2 = sv;
LIBCPP_ASSERT(s2.__invariants());
assert(s2.size() == sv.size());
assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
assert(s2.get_allocator() == a);
assert(s2.capacity() >= s2.size());
}
}
void
test(int i)
{
typedef std::error_code T;
typedef std::hash<T> H;
static_assert((std::is_same<H::argument_type, T>::value), "" );
static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
ASSERT_NOEXCEPT(H()(T()));
H h;
T ec(i, std::system_category());
const std::size_t result = h(ec);
LIBCPP_ASSERT(result == static_cast<std::size_t>(i));
((void)result); // Prevent unused warning
}
void
test(S s, typename S::size_type n, S expected)
{
try
{
s.resize(n);
LIBCPP_ASSERT(s.__invariants());
assert(n <= s.max_size());
assert(s == expected);
}
catch (std::length_error&)
{
assert(n > s.max_size());
}
}
void
test(It first, It last, const A& a)
{
typedef typename std::iterator_traits<It>::value_type charT;
typedef std::basic_string<charT, std::char_traits<charT>, A> S;
typedef typename S::traits_type T;
S s2(first, last, a);
LIBCPP_ASSERT(s2.__invariants());
assert(s2.size() == std::distance(first, last));
unsigned i = 0;
for (It it = first; it != last; ++it, ++i)
assert(s2[i] == *it);
assert(s2.get_allocator() == a);
assert(s2.capacity() >= s2.size());
}
static int
test(const charT* s)
{
typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
typedef typename S::traits_type T;
typedef typename S::allocator_type A;
std::size_t n = T::length(s);
S s2(s);
LIBCPP_ASSERT(s2.__invariants());
TC_ASSERT_EXPR(s2.size() == n);
TC_ASSERT_EXPR(T::compare(s2.data(), s, n) == 0);
TC_ASSERT_EXPR(s2.get_allocator() == A());
TC_ASSERT_EXPR(s2.capacity() >= s2.size());
return 0;
}
void
test_npos(S s, SV sv, typename S::size_type pos, S expected)
{
try
{
s.append(sv, pos);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= sv.size());
assert(s == expected);
}
catch (std::out_of_range&)
{
assert(pos > sv.size());
}
}
void
test1(const typename C::allocator_type& a)
{
#if TEST_STD_VER > 14
static_assert((noexcept(C {
typename C::allocator_type {}
})), "" );
#elif TEST_STD_VER >= 11
static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
#endif
C c(a);
LIBCPP_ASSERT(c.__invariants());
assert(c.empty());
assert(c.get_allocator() == a);
}
void
test_with_iterator()
{
int ia[] = {1, 2, 3, 4};
int ia1[] = {4, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
gen r;
std::random_shuffle(ia, ia+sa, r);
LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
assert(std::is_permutation(ia, ia+sa, ia1));
std::random_shuffle(ia, ia+sa, r);
assert(std::is_permutation(ia, ia+sa, ia1));
}
void
test(S s, typename S::size_type pos, S str, S expected)
{
typename S::size_type old_size = s.size();
S s0 = s;
try
{
s.insert(pos, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
void
test_w(const char_type* A,
typename std::regex_traits<char_type>::char_class_type expected,
bool icase = false)
{
typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
std::regex_traits<char_type> t;
typedef forward_iterator<const char_type*> F;
char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
assert((result & expected) == expected);
LIBCPP_ASSERT((expected | std::regex_traits<char_type>::__regex_word) == result);
const bool matches_underscore = t.isctype('_', result);
if (result != expected)
assert(matches_underscore && "expected to match underscore");
else
assert(!matches_underscore && "should not match underscore");
}
int main()
{
{
std::vector<int> v(100);
v.push_back(1);
assert(is_contiguous_container_asan_correct(v));
v.shrink_to_fit();
assert(v.capacity() == 101);
assert(v.size() == 101);
assert(is_contiguous_container_asan_correct(v));
}
{
std::vector<int, limited_allocator<int, 401> > v(100);
v.push_back(1);
assert(is_contiguous_container_asan_correct(v));
v.shrink_to_fit();
assert(v.capacity() == 101);
assert(v.size() == 101);
assert(is_contiguous_container_asan_correct(v));
}
#ifndef _LIBCPP_NO_EXCEPTIONS
{
std::vector<int, limited_allocator<int, 400> > v(100);
v.push_back(1);
assert(is_contiguous_container_asan_correct(v));
v.shrink_to_fit();
LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor
assert(v.size() == 101);
assert(is_contiguous_container_asan_correct(v));
}
#endif
#if TEST_STD_VER >= 11
{
std::vector<int, min_allocator<int>> v(100);
v.push_back(1);
assert(is_contiguous_container_asan_correct(v));
v.shrink_to_fit();
assert(v.capacity() == 101);
assert(v.size() == 101);
assert(is_contiguous_container_asan_correct(v));
}
#endif
}
int main()
{
{
std::random_device r;
std::random_device::result_type e = r();
((void)e); // Prevent unused warning
}
#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
std::random_device r("/dev/null");
(void)r();
LIBCPP_ASSERT(false);
}
catch (const std::system_error&)
{
}
#endif
}
void
test()
{
typedef std::hash<T> H;
static_assert((std::is_same<typename H::argument_type, T>::value), "" );
static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
ASSERT_NOEXCEPT(H()(T()));
H h;
for (int i = 0; i <= 5; ++i)
{
T t(static_cast<T>(i));
const bool small = std::integral_constant<bool, sizeof(T) <= sizeof(std::size_t)>::value; // avoid compiler warnings
if (small)
{
const std::size_t result = h(t);
LIBCPP_ASSERT(result == static_cast<size_t>(t));
((void)result); // Prevent unused warning
}
}
}
int main(int, char**)
{
{
typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible>
> C;
C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
return 0;
}
int tc_libcxx_containers_unord_map_cnstr_size_pass(void)
{
{
typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
test_allocator<std::pair<const NotConstructible,
NotConstructible> >
> C;
C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7);
TC_ASSERT_EXPR(c.hash_function() == test_hash<std::hash<NotConstructible> >());
TC_ASSERT_EXPR(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
TC_ASSERT_EXPR(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
TC_ASSERT_EXPR(c.size() == 0);
TC_ASSERT_EXPR(c.empty());
TC_ASSERT_EXPR(std::distance(c.begin(), c.end()) == 0);
TC_ASSERT_EXPR(c.load_factor() == 0);
TC_ASSERT_EXPR(c.max_load_factor() == 1);
}
TC_SUCCESS_RESULT();
return 0;
}
int main(int, char**)
{
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) ==
(static_cast<int>(std::launch::async) | static_cast<int>(std::launch::deferred)), "");
#else
LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async | std::launch::deferred), "");
static_assert(std::launch(0) == (std::launch::async & std::launch::deferred), "");
LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async ^ std::launch::deferred), "");
LIBCPP_STATIC_ASSERT(std::launch::deferred == ~std::launch::async, "");
std::launch x = std::launch::async;
x &= std::launch::deferred;
assert(x == std::launch(0));
x = std::launch::async;
x |= std::launch::deferred;
LIBCPP_ASSERT(x == std::launch::any);
x ^= std::launch::deferred;
assert(x == std::launch::async);
#endif
static_assert(static_cast<int>(std::launch::async) == 1, "");
static_assert(static_cast<int>(std::launch::deferred) == 2, "");
return 0;
}
void
test_npos(S s, S str, typename S::size_type pos, S expected)
{
if (pos <= str.size())
{
s.append(str, pos);
LIBCPP_ASSERT(s.__invariants());
assert(s == expected);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
try
{
s.append(str, pos);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > str.size());
}
}
#endif
}
void
test(S s, typename S::size_type n, S expected)
{
if (n <= s.max_size())
{
s.resize(n);
LIBCPP_ASSERT(s.__invariants());
assert(s == expected);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
try
{
s.resize(n);
assert(false);
}
catch (std::length_error&)
{
assert(n > s.max_size());
}
}
#endif
}
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
typedef std::unordered_set<int,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
test_allocator<int>
> C;
typedef int P;
C c({
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
},
7,
test_hash<std::hash<int> >(8)
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
{
typedef std::unordered_set<int,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
min_allocator<int>
> C;
typedef int P;
C c({
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
},
7,
test_hash<std::hash<int> >(8)
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}
int main(int, char**)
{
{
typedef std::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]));
test(c);
assert(c.bucket_count() >= 7);
c.reserve(3);
LIBCPP_ASSERT(c.bucket_count() == 7);
test(c);
c.max_load_factor(2);
c.reserve(3);
LIBCPP_ASSERT(c.bucket_count() == 3);
test(c);
c.reserve(31);
assert(c.bucket_count() >= 16);
test(c);
}
#if TEST_STD_VER >= 11
{
typedef std::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]));
test(c);
assert(c.bucket_count() >= 7);
c.reserve(3);
LIBCPP_ASSERT(c.bucket_count() == 7);
test(c);
c.max_load_factor(2);
c.reserve(3);
LIBCPP_ASSERT(c.bucket_count() == 3);
test(c);
c.reserve(31);
assert(c.bucket_count() >= 16);
test(c);
}
#endif
reserve_invariant(20);
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_set<int,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
test_allocator<int>
> C;
C c0(7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
test_allocator<int>(10)
);
C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
{
typedef std::unordered_set<int,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
test_allocator<int>
> C;
typedef int P;
P a[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
C c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
test_allocator<int>(10)
);
C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
{
typedef std::unordered_set<int,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
min_allocator<int>
> C;
C c0(7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
min_allocator<int>()
);
C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
{
typedef std::unordered_set<int,
test_hash<std::hash<int> >,
test_compare<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 c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
min_allocator<int>()
);
C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
#if _LIBCPP_DEBUG >= 1
{
std::unordered_set<int> s1 = {1, 2, 3};
std::unordered_set<int>::iterator i = s1.begin();
int k = *i;
std::unordered_set<int> s2 = std::move(s1);
assert(*i == k);
s2.erase(i);
assert(s2.size() == 2);
}
#endif
}
int main()
{
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator().get_id() == 1);
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator().get_id() == 1);
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator().get_id() == 1);
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator().get_id() == 1);
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(0, Hash(1), Compare(1), Alloc());
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2);
swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare;
typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P;
P a1[] =
{
P(1),
P(2),
P(3),
P(4),
P(1),
P(2)
};
P a2[] =
{
P(10),
P(20),
P(30),
P(40),
P(50),
P(60),
P(70),
P(80)
};
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2);
swap(c1, c2);
assert(c1.bucket_count() >= 8);
assert(c1.size() == 8);
assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.size() == 4);
assert(c2.count(1) == 1);
assert(c2.count(2) == 1);
assert(c2.count(3) == 1);
assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
}