This is an archive of the discontinued LLVM Phabricator instance.

Differential D26623

[libcxx] [test] Swapping non-equal non-POCS allocators is UB.
AbandonedPublic

Authored by STL_MSFT on Nov 14 2016, 12:04 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

[libcxx] [test] Swapping non-equal non-POCS allocators is UB.

test_allocator is a non-POCS allocator. Instead of swapping containers
with A(1) and A(2), which triggers undefined behavior,
swapping A(3) with A(3) is conformant.

test/std/containers/sequences/vector/vector.special/swap.pass.cpp
Remove "#ifndef _LIBCPP_DEBUG_LEVEL" and a comment about
the now-fixed undefined behavior.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 77854.Nov 14 2016, 12:04 PM
STL_MSFT retitled this revision from to [libcxx] [test] Swapping non-equal non-POCS allocators is UB..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
Herald edited edge metadata. · View Herald TranscriptNov 14 2016, 12:04 PM
mclow.lists edited edge metadata.Nov 15 2016, 7:05 AM

I'm working on this, too.
Trying to decide what the right choice is here.

STL_MSFT updated this revision to Diff 80352.Dec 5 2016, 5:33 PM
STL_MSFT edited edge metadata.

Merged with the recent addition of static_cast<std::size_t> to various lines in the unordered container tests. No actual changes to the diff, only to the context.

EricWF edited edge metadata.Dec 10 2016, 7:53 PM

I hope you don't mind but I committed by own version of this change as r289358. I was concerned about testing that the container didn't actually perform a swap, so I modified test_allocator to take an "id" parameter that does not participate in equality. I then changed the tests to check that the "id" was unchanged after the swap.

Once confirming that r289358 fixes your issues could you please close this review?

EricWF mentioned this in rL289358: Fix undefined behavior in container swap tests..Dec 11 2016, 1:40 PM
STL_MSFT abandoned this revision.Dec 12 2016, 12:44 PM

r289358 fixes everything for me, thanks! Abandoning this revision.

Revision Contents

PathSize
test/
std/
containers/
associative/
map/
map.special/
8 lines
multimap/
multimap.special/
8 lines
multiset/
multiset.special/
8 lines
set/
set.special/
8 lines
sequences/
deque/
deque.special/
8 lines
forwardlist/
forwardlist.spec/
32 lines
32 lines
vector.bool/
8 lines
vector/
vector.special/
11 lines
unord/
unord.map/
32 lines
unord.map.swap/
32 lines
unord.multimap/
32 lines
unord.multimap.swap/
32 lines
unord.multiset/
32 lines
unord.multiset.swap/
32 lines
unord.set/
32 lines
unord.set.swap/
32 lines

Diff 80352

test/std/containers/associative/map/map.special/non_member_swap.pass.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines typedef std::map<int, double> M;
V(6, 6), V(6, 6),
V(7, 7), V(7, 7),
V(8, 8), V(8, 8),
V(9, 9), V(9, 9),
V(10, 10), V(10, 10),
V(11, 11), V(11, 11),
V(12, 12) V(12, 12)
}; };
M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1)); M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(3));
M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2)); M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(3));
M m1_save = m1; M m1_save = m1;
M m2_save = m2; M m2_save = m2;
swap(m1, m2); swap(m1, m2);
assert(m1 == m2_save); assert(m1 == m2_save);
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator() == A(1)); assert(m1.get_allocator() == A(3));
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator() == A(2)); assert(m2.get_allocator() == A(3));
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_compare<std::less<int> > C;
typedef std::map<int, double, C, A> M; typedef std::map<int, double, C, A> M;
V ar1[] = V ar1[] =
{ {
V(1, 1), V(1, 1),
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines typedef std::multimap<int, double> M;
V(6, 6), V(6, 6),
V(7, 7), V(7, 7),
V(8, 8), V(8, 8),
V(9, 9), V(9, 9),
V(10, 10), V(10, 10),
V(11, 11), V(11, 11),
V(12, 12) V(12, 12)
}; };
M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1)); M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(3));
M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2)); M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(3));
M m1_save = m1; M m1_save = m1;
M m2_save = m2; M m2_save = m2;
swap(m1, m2); swap(m1, m2);
assert(m1 == m2_save); assert(m1 == m2_save);
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator() == A(1)); assert(m1.get_allocator() == A(3));
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator() == A(2)); assert(m2.get_allocator() == A(3));
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_compare<std::less<int> > C;
typedef std::multimap<int, double, C, A> M; typedef std::multimap<int, double, C, A> M;
V ar1[] = V ar1[] =
{ {
V(1, 1), V(1, 1),
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines typedef std::multiset<int> M;
6, 6,
7, 7,
8, 8,
9, 9,
10, 10,
11, 11,
12 12
}; };
M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1)); M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(3));
M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2)); M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(3));
M m1_save = m1; M m1_save = m1;
M m2_save = m2; M m2_save = m2;
swap(m1, m2); swap(m1, m2);
assert(m1 == m2_save); assert(m1 == m2_save);
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator() == A(1)); assert(m1.get_allocator() == A(3));
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator() == A(2)); assert(m2.get_allocator() == A(3));
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_compare<std::less<int> > C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
Show All 28 Lines

test/std/containers/associative/set/set.special/non_member_swap.pass.cpp

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines typedef std::set<int> M;
6, 6,
7, 7,
8, 8,
9, 9,
10, 10,
11, 11,
12 12
}; };
M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(1)); M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]), C(1), A(3));
M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(2)); M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]), C(2), A(3));
M m1_save = m1; M m1_save = m1;
M m2_save = m2; M m2_save = m2;
swap(m1, m2); swap(m1, m2);
assert(m1 == m2_save); assert(m1 == m2_save);
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator() == A(1)); assert(m1.get_allocator() == A(3));
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator() == A(2)); assert(m2.get_allocator() == A(3));
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_compare<std::less<int> > C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
Show All 28 Lines

test/std/containers/sequences/deque/deque.special/swap.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Linesint main()
for (int j = 0; j < N; ++j) for (int j = 0; j < N; ++j)
for (int k = 0; k < N; ++k) for (int k = 0; k < N; ++k)
testN<std::deque<int> >(rng[i], rng[j], rng[k]); testN<std::deque<int> >(rng[i], rng[j], rng[k]);
} }
{ {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef test_allocator<int> A; typedef test_allocator<int> A;
std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(3));
std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(3));
swap(c1, c2); swap(c1, c2);
assert((c1 == std::deque<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0])))); assert((c1 == std::deque<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0])))); assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef other_allocator<int> A; typedef other_allocator<int> A;
std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
swap(c1, c2); swap(c1, c2);
Show All 28 Lines

test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp

Show All 18 Lines
int main() int main()
{ {
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(3));
const T t2[] = {10, 11, 12}; const T t2[] = {10, 11, 12};
C c2(std::begin(t2), std::end(t2), A(2)); C c2(std::begin(t2), std::end(t2), A(3));
c1.swap(c2); c1.swap(c2);
assert(distance(c1.begin(), c1.end()) == 3); assert(distance(c1.begin(), c1.end()) == 3);
assert(*next(c1.begin(), 0) == 10); assert(*next(c1.begin(), 0) == 10);
assert(*next(c1.begin(), 1) == 11); assert(*next(c1.begin(), 1) == 11);
assert(*next(c1.begin(), 2) == 12); assert(*next(c1.begin(), 2) == 12);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 6); assert(distance(c2.begin(), c2.end()) == 6);
assert(*next(c2.begin(), 0) == 0); assert(*next(c2.begin(), 0) == 0);
assert(*next(c2.begin(), 1) == 1); assert(*next(c2.begin(), 1) == 1);
assert(*next(c2.begin(), 2) == 2); assert(*next(c2.begin(), 2) == 2);
assert(*next(c2.begin(), 3) == 3); assert(*next(c2.begin(), 3) == 3);
assert(*next(c2.begin(), 4) == 4); assert(*next(c2.begin(), 4) == 4);
assert(*next(c2.begin(), 5) == 5); assert(*next(c2.begin(), 5) == 5);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(3));
C c2(A(2)); C c2(A(3));
c1.swap(c2); c1.swap(c2);
assert(distance(c1.begin(), c1.end()) == 0); assert(distance(c1.begin(), c1.end()) == 0);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 6); assert(distance(c2.begin(), c2.end()) == 6);
assert(*next(c2.begin(), 0) == 0); assert(*next(c2.begin(), 0) == 0);
assert(*next(c2.begin(), 1) == 1); assert(*next(c2.begin(), 1) == 1);
assert(*next(c2.begin(), 2) == 2); assert(*next(c2.begin(), 2) == 2);
assert(*next(c2.begin(), 3) == 3); assert(*next(c2.begin(), 3) == 3);
assert(*next(c2.begin(), 4) == 4); assert(*next(c2.begin(), 4) == 4);
assert(*next(c2.begin(), 5) == 5); assert(*next(c2.begin(), 5) == 5);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
C c1(A(1)); C c1(A(3));
const T t2[] = {10, 11, 12}; const T t2[] = {10, 11, 12};
C c2(std::begin(t2), std::end(t2), A(2)); C c2(std::begin(t2), std::end(t2), A(3));
c1.swap(c2); c1.swap(c2);
assert(distance(c1.begin(), c1.end()) == 3); assert(distance(c1.begin(), c1.end()) == 3);
assert(*next(c1.begin(), 0) == 10); assert(*next(c1.begin(), 0) == 10);
assert(*next(c1.begin(), 1) == 11); assert(*next(c1.begin(), 1) == 11);
assert(*next(c1.begin(), 2) == 12); assert(*next(c1.begin(), 2) == 12);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 0); assert(distance(c2.begin(), c2.end()) == 0);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
C c1(A(1)); C c1(A(3));
C c2(A(2)); C c2(A(3));
c1.swap(c2); c1.swap(c2);
assert(distance(c1.begin(), c1.end()) == 0); assert(distance(c1.begin(), c1.end()) == 0);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 0); assert(distance(c2.begin(), c2.end()) == 0);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef other_allocator<T> A; typedef other_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(1));
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp

Show All 19 Lines
int main() int main()
{ {
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(3));
const T t2[] = {10, 11, 12}; const T t2[] = {10, 11, 12};
C c2(std::begin(t2), std::end(t2), A(2)); C c2(std::begin(t2), std::end(t2), A(3));
swap(c1, c2); swap(c1, c2);
assert(distance(c1.begin(), c1.end()) == 3); assert(distance(c1.begin(), c1.end()) == 3);
assert(*next(c1.begin(), 0) == 10); assert(*next(c1.begin(), 0) == 10);
assert(*next(c1.begin(), 1) == 11); assert(*next(c1.begin(), 1) == 11);
assert(*next(c1.begin(), 2) == 12); assert(*next(c1.begin(), 2) == 12);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 6); assert(distance(c2.begin(), c2.end()) == 6);
assert(*next(c2.begin(), 0) == 0); assert(*next(c2.begin(), 0) == 0);
assert(*next(c2.begin(), 1) == 1); assert(*next(c2.begin(), 1) == 1);
assert(*next(c2.begin(), 2) == 2); assert(*next(c2.begin(), 2) == 2);
assert(*next(c2.begin(), 3) == 3); assert(*next(c2.begin(), 3) == 3);
assert(*next(c2.begin(), 4) == 4); assert(*next(c2.begin(), 4) == 4);
assert(*next(c2.begin(), 5) == 5); assert(*next(c2.begin(), 5) == 5);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(3));
C c2(A(2)); C c2(A(3));
swap(c1, c2); swap(c1, c2);
assert(distance(c1.begin(), c1.end()) == 0); assert(distance(c1.begin(), c1.end()) == 0);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 6); assert(distance(c2.begin(), c2.end()) == 6);
assert(*next(c2.begin(), 0) == 0); assert(*next(c2.begin(), 0) == 0);
assert(*next(c2.begin(), 1) == 1); assert(*next(c2.begin(), 1) == 1);
assert(*next(c2.begin(), 2) == 2); assert(*next(c2.begin(), 2) == 2);
assert(*next(c2.begin(), 3) == 3); assert(*next(c2.begin(), 3) == 3);
assert(*next(c2.begin(), 4) == 4); assert(*next(c2.begin(), 4) == 4);
assert(*next(c2.begin(), 5) == 5); assert(*next(c2.begin(), 5) == 5);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
C c1(A(1)); C c1(A(3));
const T t2[] = {10, 11, 12}; const T t2[] = {10, 11, 12};
C c2(std::begin(t2), std::end(t2), A(2)); C c2(std::begin(t2), std::end(t2), A(3));
swap(c1, c2); swap(c1, c2);
assert(distance(c1.begin(), c1.end()) == 3); assert(distance(c1.begin(), c1.end()) == 3);
assert(*next(c1.begin(), 0) == 10); assert(*next(c1.begin(), 0) == 10);
assert(*next(c1.begin(), 1) == 11); assert(*next(c1.begin(), 1) == 11);
assert(*next(c1.begin(), 2) == 12); assert(*next(c1.begin(), 2) == 12);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 0); assert(distance(c2.begin(), c2.end()) == 0);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
C c1(A(1)); C c1(A(3));
C c2(A(2)); C c2(A(3));
swap(c1, c2); swap(c1, c2);
assert(distance(c1.begin(), c1.end()) == 0); assert(distance(c1.begin(), c1.end()) == 0);
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert(distance(c2.begin(), c2.end()) == 0); assert(distance(c2.begin(), c2.end()) == 0);
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
{ {
typedef int T; typedef int T;
typedef other_allocator<T> A; typedef other_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
const T t1[] = {0, 1, 2, 3, 4, 5}; const T t1[] = {0, 1, 2, 3, 4, 5};
C c1(std::begin(t1), std::end(t1), A(1)); C c1(std::begin(t1), std::end(t1), A(1));
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

test/std/containers/sequences/vector.bool/swap.pass.cpp

Show All 24 Linesint main()
v1.swap(v2); v1.swap(v2);
assert(v1.size() == 200); assert(v1.size() == 200);
assert(v1.capacity() >= 200); assert(v1.capacity() >= 200);
assert(v2.size() == 100); assert(v2.size() == 100);
assert(v2.capacity() >= 100); assert(v2.capacity() >= 100);
} }
{ {
typedef test_allocator<bool> A; typedef test_allocator<bool> A;
std::vector<bool, A> v1(100, true, A(1)); std::vector<bool, A> v1(100, true, A(3));
std::vector<bool, A> v2(200, false, A(2)); std::vector<bool, A> v2(200, false, A(3));
swap(v1, v2); swap(v1, v2);
assert(v1.size() == 200); assert(v1.size() == 200);
assert(v1.capacity() >= 200); assert(v1.capacity() >= 200);
assert(v2.size() == 100); assert(v2.size() == 100);
assert(v2.capacity() >= 100); assert(v2.capacity() >= 100);
assert(v1.get_allocator() == A(1)); assert(v1.get_allocator() == A(3));
assert(v2.get_allocator() == A(2)); assert(v2.get_allocator() == A(3));
} }
{ {
typedef other_allocator<bool> A; typedef other_allocator<bool> A;
std::vector<bool, A> v1(100, true, A(1)); std::vector<bool, A> v1(100, true, A(1));
std::vector<bool, A> v2(200, false, A(2)); std::vector<bool, A> v2(200, false, A(2));
swap(v1, v2); swap(v1, v2);
assert(v1.size() == 200); assert(v1.size() == 200);
assert(v1.capacity() >= 200); assert(v1.capacity() >= 200);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/std/containers/sequences/vector/vector.special/swap.pass.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linesint main()
swap(c1, c2); swap(c1, c2);
assert(c1.empty()); assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0); assert(distance(c1.begin(), c1.end()) == 0);
assert(c2.empty()); assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0); assert(distance(c2.begin(), c2.end()) == 0);
assert(is_contiguous_container_asan_correct(c1)); assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2)); assert(is_contiguous_container_asan_correct(c2));
} }
#ifndef _LIBCPP_DEBUG_LEVEL
// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
{ {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef test_allocator<int> A; typedef test_allocator<int> A;
std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(3));
std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(3));
swap(c1, c2); swap(c1, c2);
assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0])))); assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator() == A(1)); assert(c1.get_allocator() == A(3));
assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0])))); assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A(2)); assert(c2.get_allocator() == A(3));
} }
#endif
{ {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef other_allocator<int> A; typedef other_allocator<int> A;
std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
assert(is_contiguous_container_asan_correct(c1)); assert(is_contiguous_container_asan_correct(c1));
assert(is_contiguous_container_asan_correct(c2)); assert(is_contiguous_container_asan_correct(c2));
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/std/containers/unord/unord.map/swap_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.at(10) == "ten"); assert(c1.at(10) == "ten");
assert(c1.at(20) == "twenty"); assert(c1.at(20) == "twenty");
assert(c1.at(30) == "thirty"); assert(c1.at(30) == "thirty");
assert(c1.at(40) == "forty"); assert(c1.at(40) == "forty");
assert(c1.at(50) == "fifty"); assert(c1.at(50) == "fifty");
assert(c1.at(60) == "sixty"); assert(c1.at(60) == "sixty");
assert(c1.at(70) == "seventy"); assert(c1.at(70) == "seventy");
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.at(1) == "one"); assert(c2.at(1) == "one");
assert(c2.at(2) == "two"); assert(c2.at(2) == "two");
assert(c2.at(3) == "three"); assert(c2.at(3) == "three");
assert(c2.at(4) == "four"); assert(c2.at(4) == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
Show All 14 Linesint main()
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.at(10) == "ten"); assert(c1.at(10) == "ten");
assert(c1.at(20) == "twenty"); assert(c1.at(20) == "twenty");
assert(c1.at(30) == "thirty"); assert(c1.at(30) == "thirty");
assert(c1.at(40) == "forty"); assert(c1.at(40) == "forty");
assert(c1.at(50) == "fifty"); assert(c1.at(50) == "fifty");
assert(c1.at(60) == "sixty"); assert(c1.at(60) == "sixty");
assert(c1.at(70) == "seventy"); assert(c1.at(70) == "seventy");
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.at(1) == "one"); assert(c2.at(1) == "one");
assert(c2.at(2) == "two"); assert(c2.at(2) == "two");
assert(c2.at(3) == "three"); assert(c2.at(3) == "three");
assert(c2.at(4) == "four"); assert(c2.at(4) == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.at(10) == "ten"); assert(c1.at(10) == "ten");
assert(c1.at(20) == "twenty"); assert(c1.at(20) == "twenty");
assert(c1.at(30) == "thirty"); assert(c1.at(30) == "thirty");
assert(c1.at(40) == "forty"); assert(c1.at(40) == "forty");
assert(c1.at(50) == "fifty"); assert(c1.at(50) == "fifty");
assert(c1.at(60) == "sixty"); assert(c1.at(60) == "sixty");
assert(c1.at(70) == "seventy"); assert(c1.at(70) == "seventy");
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.at(1) == "one"); assert(c2.at(1) == "one");
assert(c2.at(2) == "two"); assert(c2.at(2) == "two");
assert(c2.at(3) == "three"); assert(c2.at(3) == "three");
assert(c2.at(4) == "four"); assert(c2.at(4) == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
Show All 14 Linesint main()
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.at(10) == "ten"); assert(c1.at(10) == "ten");
assert(c1.at(20) == "twenty"); assert(c1.at(20) == "twenty");
assert(c1.at(30) == "thirty"); assert(c1.at(30) == "thirty");
assert(c1.at(40) == "forty"); assert(c1.at(40) == "forty");
assert(c1.at(50) == "fifty"); assert(c1.at(50) == "fifty");
assert(c1.at(60) == "sixty"); assert(c1.at(60) == "sixty");
assert(c1.at(70) == "seventy"); assert(c1.at(70) == "seventy");
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.at(1) == "one"); assert(c2.at(1) == "one");
assert(c2.at(2) == "two"); assert(c2.at(2) == "two");
assert(c2.at(3) == "three"); assert(c2.at(3) == "three");
assert(c2.at(4) == "four"); assert(c2.at(4) == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multimap/swap_member.pass.cpp

Show All 29 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.find(10)->second == "ten"); assert(c1.find(10)->second == "ten");
assert(c1.find(20)->second == "twenty"); assert(c1.find(20)->second == "twenty");
assert(c1.find(30)->second == "thirty"); assert(c1.find(30)->second == "thirty");
assert(c1.find(40)->second == "forty"); assert(c1.find(40)->second == "forty");
assert(c1.find(50)->second == "fifty"); assert(c1.find(50)->second == "fifty");
assert(c1.find(60)->second == "sixty"); assert(c1.find(60)->second == "sixty");
assert(c1.find(70)->second == "seventy"); assert(c1.find(70)->second == "seventy");
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.find(1)->second == "one"); assert(c2.find(1)->second == "one");
assert(next(c2.find(1))->second == "four"); assert(next(c2.find(1))->second == "four");
assert(c2.find(2)->second == "two"); assert(c2.find(2)->second == "two");
assert(next(c2.find(2))->second == "four"); assert(next(c2.find(2))->second == "four");
assert(c2.find(3)->second == "three"); assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four"); assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
Show All 14 Linesint main()
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.find(10)->second == "ten"); assert(c1.find(10)->second == "ten");
assert(c1.find(20)->second == "twenty"); assert(c1.find(20)->second == "twenty");
assert(c1.find(30)->second == "thirty"); assert(c1.find(30)->second == "thirty");
assert(c1.find(40)->second == "forty"); assert(c1.find(40)->second == "forty");
assert(c1.find(50)->second == "fifty"); assert(c1.find(50)->second == "fifty");
assert(c1.find(60)->second == "sixty"); assert(c1.find(60)->second == "sixty");
assert(c1.find(70)->second == "seventy"); assert(c1.find(70)->second == "seventy");
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.find(1)->second == "one"); assert(c2.find(1)->second == "one");
assert(next(c2.find(1))->second == "four"); assert(next(c2.find(1))->second == "four");
assert(c2.find(2)->second == "two"); assert(c2.find(2)->second == "two");
assert(next(c2.find(2))->second == "four"); assert(next(c2.find(2))->second == "four");
assert(c2.find(3)->second == "three"); assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four"); assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp

Show All 28 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.find(10)->second == "ten"); assert(c1.find(10)->second == "ten");
assert(c1.find(20)->second == "twenty"); assert(c1.find(20)->second == "twenty");
assert(c1.find(30)->second == "thirty"); assert(c1.find(30)->second == "thirty");
assert(c1.find(40)->second == "forty"); assert(c1.find(40)->second == "forty");
assert(c1.find(50)->second == "fifty"); assert(c1.find(50)->second == "fifty");
assert(c1.find(60)->second == "sixty"); assert(c1.find(60)->second == "sixty");
assert(c1.find(70)->second == "seventy"); assert(c1.find(70)->second == "seventy");
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.find(1)->second == "one"); assert(c2.find(1)->second == "one");
assert(next(c2.find(1))->second == "four"); assert(next(c2.find(1))->second == "four");
assert(c2.find(2)->second == "two"); assert(c2.find(2)->second == "two");
assert(next(c2.find(2))->second == "four"); assert(next(c2.find(2))->second == "four");
assert(c2.find(3)->second == "three"); assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four"); assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
Show All 14 Linesint main()
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(c1.find(10)->second == "ten"); assert(c1.find(10)->second == "ten");
assert(c1.find(20)->second == "twenty"); assert(c1.find(20)->second == "twenty");
assert(c1.find(30)->second == "thirty"); assert(c1.find(30)->second == "thirty");
assert(c1.find(40)->second == "forty"); assert(c1.find(40)->second == "forty");
assert(c1.find(50)->second == "fifty"); assert(c1.find(50)->second == "fifty");
assert(c1.find(60)->second == "sixty"); assert(c1.find(60)->second == "sixty");
assert(c1.find(70)->second == "seventy"); assert(c1.find(70)->second == "seventy");
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.find(1)->second == "one"); assert(c2.find(1)->second == "one");
assert(next(c2.find(1))->second == "four"); assert(next(c2.find(1))->second == "four");
assert(c2.find(2)->second == "two"); assert(c2.find(2)->second == "two");
assert(next(c2.find(2))->second == "four"); assert(next(c2.find(2))->second == "four");
assert(c2.find(3)->second == "three"); assert(c2.find(3)->second == "three");
assert(c2.find(4)->second == "four"); assert(c2.find(4)->second == "four");
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multiset/swap_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.count(1) == 2); assert(c2.count(1) == 2);
assert(c2.count(2) == 2); assert(c2.count(2) == 2);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
Show All 14 Linesint main()
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.count(1) == 2); assert(c2.count(1) == 2);
assert(c2.count(2) == 2); assert(c2.count(2) == 2);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.count(1) == 2); assert(c2.count(1) == 2);
assert(c2.count(2) == 2); assert(c2.count(2) == 2);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
Show All 14 Linesint main()
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6); assert(c2.bucket_count() >= 6);
assert(c2.size() == 6); assert(c2.size() == 6);
assert(c2.count(1) == 2); assert(c2.count(1) == 2);
assert(c2.count(2) == 2); assert(c2.count(2) == 2);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines

test/std/containers/unord/unord.set/swap_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.count(1) == 1); assert(c2.count(1) == 1);
assert(c2.count(2) == 1); assert(c2.count(2) == 1);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
Show All 14 Linesint main()
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.count(1) == 1); assert(c2.count(1) == 1);
assert(c2.count(2) == 1); assert(c2.count(2) == 1);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines

test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp

Show All 27 Lines
int main() int main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
LIBCPP_ASSERT(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.count(1) == 1); assert(c2.count(1) == 1);
assert(c2.count(2) == 1); assert(c2.count(2) == 1);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
Show All 14 Linesint main()
P(20), P(20),
P(30), P(30),
P(40), P(40),
P(50), P(50),
P(60), P(60),
P(70), P(70),
P(80) P(80)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(3));
C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(3));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
assert(c1.bucket_count() >= 8); assert(c1.bucket_count() >= 8);
assert(c1.size() == 8); assert(c1.size() == 8);
assert(*c1.find(10) == 10); assert(*c1.find(10) == 10);
assert(*c1.find(20) == 20); assert(*c1.find(20) == 20);
assert(*c1.find(30) == 30); assert(*c1.find(30) == 30);
assert(*c1.find(40) == 40); assert(*c1.find(40) == 40);
assert(*c1.find(50) == 50); assert(*c1.find(50) == 50);
assert(*c1.find(60) == 60); assert(*c1.find(60) == 60);
assert(*c1.find(70) == 70); assert(*c1.find(70) == 70);
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); 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(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4); assert(c2.bucket_count() >= 4);
assert(c2.size() == 4); assert(c2.size() == 4);
assert(c2.count(1) == 1); assert(c2.count(1) == 1);
assert(c2.count(2) == 1); assert(c2.count(2) == 1);
assert(c2.count(3) == 1); assert(c2.count(3) == 1);
assert(c2.count(4) == 1); assert(c2.count(4) == 1);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(3));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); 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(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines