This is an archive of the discontinued LLVM Phabricator instance.

Differential D103366

[libc++] [test] Update "test_compare.h" users to avoid removed-in-C++20 members. NFCI.
ClosedPublic

Authored by • Quuxplusone on May 29 2021, 10:47 AM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rG5cc55fdb57c9: [libc++] [test] Update "test_compare.h" users to avoid removed-in-C++20 members.
Summary

If buildkite likes this, imma land it.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.May 29 2021, 10:47 AM
• Quuxplusone created this revision.
Herald added a reviewer: Restricted Project. · View Herald TranscriptMay 29 2021, 10:47 AM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
This revision was not accepted when it landed; it landed in state Needs Review.May 29 2021, 1:55 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG5cc55fdb57c9: [libc++] [test] Update "test_compare.h" users to avoid removed-in-C++20 members. (authored by • arthur.j.odwyer). · Explain Why
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rG5cc55fdb57c9: [libc++] [test] Update "test_compare.h" users to avoid removed-in-C++20 members..
Harbormaster completed remote builds in B106809: Diff 348649.May 31 2021, 11:25 AM

Revision Contents

PathSize
libcxx/
test/
std/
containers/
associative/
map/
map.cons/
4 lines
6 lines
6 lines
6 lines
12 lines
4 lines
8 lines
4 lines
8 lines
8 lines
10 lines
8 lines
map.special/
6 lines
multimap/
multimap.cons/
4 lines
6 lines
6 lines
6 lines
6 lines
4 lines
8 lines
4 lines
6 lines
8 lines
10 lines
8 lines
multimap.special/
6 lines
multiset/
multiset.cons/
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
6 lines
6 lines
8 lines
multiset.special/
4 lines
set/
set.cons/
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
6 lines
6 lines
8 lines
set.special/
4 lines
42 lines
unord/
unord.map/
24 lines
unord.map.cnstr/
16 lines
24 lines
4 lines
32 lines
18 lines
18 lines
14 lines
16 lines
8 lines
8 lines
12 lines
18 lines
24 lines
24 lines
12 lines
8 lines
8 lines
12 lines
18 lines
8 lines
8 lines
8 lines
12 lines
18 lines
unord.map.swap/
24 lines
unord.multimap/
24 lines
unord.multimap.cnstr/
16 lines
24 lines
4 lines
24 lines
18 lines
18 lines
14 lines
12 lines
8 lines
8 lines
12 lines
18 lines
24 lines
24 lines
12 lines
8 lines
8 lines
12 lines
18 lines
8 lines
8 lines
8 lines
12 lines
18 lines
unord.multimap.swap/
24 lines
unord.multiset/
24 lines
unord.multiset.cnstr/
12 lines
24 lines
4 lines
40 lines
18 lines
12 lines
14 lines
12 lines
8 lines
8 lines
12 lines
12 lines
24 lines
24 lines
12 lines
8 lines
8 lines
12 lines
12 lines
8 lines
8 lines
8 lines
12 lines
12 lines
unord.multiset.swap/
24 lines
unord.set/
24 lines
unord.set.cnstr/
12 lines
24 lines
4 lines
32 lines
18 lines
12 lines
14 lines
12 lines
8 lines
8 lines
12 lines
12 lines
24 lines
18 lines
12 lines
8 lines
8 lines
12 lines
12 lines
4 lines
8 lines
8 lines
12 lines
12 lines
unord.set.swap/
24 lines
utilities/
memory/
util.smartptr/
util.smartptr.hash/
7 lines
support/
38 lines

Diff 348659

libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::map<int, double, C> m(C(3)); const std::map<int, double, C> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3)); const std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<std::pair<const int, double> > A; typedef test_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m(C(4), A(5)); std::map<int, double, C, A> m(C(4), A(5));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A(5)); assert(m.get_allocator() == A(5));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<std::pair<const int, double> > A; typedef min_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m(C(4), A()); std::map<int, double, C, A> m(C(4), A());
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
} }
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef explicit_allocator<std::pair<const int, double> > A; typedef explicit_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m(C(4), A{}); std::map<int, double, C, A> m(C(4), A{});
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A{}); assert(m.get_allocator() == A{});
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp

Show All 30 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::map<int, double, C, A> m = mo; std::map<int, double, C, A> m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 18 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::map<int, double, C, A> m = mo; std::map<int, double, C, A> m = mo;
assert(m.get_allocator() == A(-2)); assert(m.get_allocator() == A(-2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 17 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::map<int, double, C, A> m = mo; std::map<int, double, C, A> m = mo;
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 15 Lines

libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp

Show All 30 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::map<int, double, C, A> m(mo, A(3)); std::map<int, double, C, A> m(mo, A(3));
assert(m.get_allocator() == A(3)); assert(m.get_allocator() == A(3));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 18 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::map<int, double, C, A> m(mo, A()); std::map<int, double, C, A> m(mo, A());
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 17 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef explicit_allocator<V> A; typedef explicit_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{}); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
std::map<int, double, C, A> m(mo, A{}); std::map<int, double, C, A> m(mo, A{});
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 15 Lines

libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 33 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(2)); assert(m.get_allocator() == A(2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 19 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A()); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
m = mo; m = mo;
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 18 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A()); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
m = mo; m = mo;
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 20 Lines assert(balanced_allocs());
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef counting_allocatorT<V> A; typedef counting_allocatorT<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(1)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(1));
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(2)); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(2));
m = mo; m = mo;
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 17 Lines assert(balanced_allocs());
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2) V(3, 2)
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef counting_allocatorF<V> A; typedef counting_allocatorF<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(100)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(100));
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(200)); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(200));
m = mo; m = mo;
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 15 Lines

libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::map<int, double, C> m({ std::map<int, double, C> m({
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
{3, 1}, {3, 1},
{3, 1.5}, {3, 1.5},
{3, 2} {3, 2}
}, C(3)); }, C(3));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::map<int, double, C, min_allocator<std::pair<const int, double>>> m({ std::map<int, double, C, min_allocator<std::pair<const int, double>>> m({
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
{3, 1}, {3, 1},
Show All 13 Lines

libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp

Show All 19 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<std::pair<const int, double> > A; typedef test_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m({ std::map<int, double, C, A> m({
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
{3, 1}, {3, 1},
{3, 1.5}, {3, 1.5},
{3, 2} {3, 2}
}, C(3), A(6)); }, C(3), A(6));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
assert(m.get_allocator() == A(6)); assert(m.get_allocator() == A(6));
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<std::pair<const int, double> > A; typedef min_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m({ std::map<int, double, C, A> m({
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
{3, 1}, {3, 1},
{3, 1.5}, {3, 1.5},
{3, 2} {3, 2}
}, C(3), A()); }, C(3), A());
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::map<int, double, C, A> M; typedef std::map<int, double, C, A> M;
A a; A a;
M m ({ {1, 1}, M m ({ {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
{3, 1}, {3, 1},
{3, 1.5}, {3, 1.5},
{3, 2} {3, 2}
}, a); }, a);
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.get_allocator() == a); assert(m.get_allocator() == a);
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef explicit_allocator<V> A; typedef explicit_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
A a; A a;
std::map<int, double, C, A> m({ std::map<int, double, C, A> m({
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
{2, 1.5}, {2, 1.5},
{2, 2}, {2, 2},
Show All 15 Lines

libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp

Show All 30 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::map<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5)); std::map<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
V(1, 1), V(1, 1),
V(1, 1.5), V(1, 1.5),
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5)); std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp

Show All 32 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
Show All 9 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
Show All 11 Lines V ar[] =
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
{ {
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
A a; A a;
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a ); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.get_allocator() == a); assert(m.get_allocator() == a);
} }
{ {
typedef explicit_allocator<V> A; typedef explicit_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
A a; A a;
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a ); std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(m.get_allocator() == a); assert(m.get_allocator() == a);
} }
} }
#endif #endif
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp

Show All 20 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> mo(C(5), A(7)); std::map<int, double, C, A> mo(C(5), A(7));
std::map<int, double, C, A> m = std::move(mo); std::map<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 10 Lines typedef std::pair<const int, double> V;
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::map<int, double, C, A> m = std::move(mo); std::map<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
assert(mo.get_allocator() == A(test_alloc_base::moved_value)); assert(mo.get_allocator() == A(test_alloc_base::moved_value));
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
assert(mo.size() == 0); assert(mo.size() == 0);
assert(distance(mo.begin(), mo.end()) == 0); assert(distance(mo.begin(), mo.end()) == 0);
} }
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(C(5), A()); std::map<int, double, C, A> mo(C(5), A());
std::map<int, double, C, A> m = std::move(mo); std::map<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 10 Lines typedef std::pair<const int, double> V;
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::map<int, double, C, A> m = std::move(mo); std::map<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 11 Lines

libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

Show All 23 Lines
#include "min_allocator.h" #include "min_allocator.h"
#include "Counter.h" #include "Counter.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<VC> A; typedef other_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Linesint main(int, char**)
assert(Counter_base::gConstructed >= (int)(num+3)); assert(Counter_base::gConstructed >= (int)(num+3));
assert(Counter_base::gConstructed <= (int)(num+3+m1.size()+m2.size())); assert(Counter_base::gConstructed <= (int)(num+3+m1.size()+m2.size()));
} }
assert(Counter_base::gConstructed == 0); assert(Counter_base::gConstructed == 0);
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<VC> A; typedef min_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A()); assert(m3.get_allocator() == A());
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef explicit_allocator<VC> A; typedef explicit_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 30 Lines

libcxx/test/std/containers/associative/map/map.cons/move_assign.pass.cpp

Show All 22 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<VC> A; typedef other_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<VC> A; typedef min_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M; typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 31 Lines

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

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines typedef std::map<int, double> M;
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);
} }
} }
{ {
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
Show All 17 Lines typedef std::map<int, double> M;
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator().get_id() == 1); // not swapped assert(m1.get_allocator().get_id() == 1); // not swapped
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator().get_id() == 2); assert(m2.get_allocator().get_id() == 2);
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
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);
} }
} }
{ {
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
Show All 27 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::multimap<int, double, C> m(C(3)); const std::multimap<int, double, C> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3)); const std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<std::pair<const int, double> > A; typedef test_allocator<std::pair<const int, double> > A;
std::multimap<int, double, C, A> m(C(4), A(5)); std::multimap<int, double, C, A> m(C(4), A(5));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A(5)); assert(m.get_allocator() == A(5));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<std::pair<const int, double> > A; typedef min_allocator<std::pair<const int, double> > A;
std::multimap<int, double, C, A> m(C(4), A()); std::multimap<int, double, C, A> m(C(4), A());
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
} }
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef explicit_allocator<std::pair<const int, double> > A; typedef explicit_allocator<std::pair<const int, double> > A;
std::multimap<int, double, C, A> m(C(4), A{}); std::multimap<int, double, C, A> m(C(4), A{});
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A{}); assert(m.get_allocator() == A{});
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp

Show All 30 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multimap<int, double, C, A> m = mo; std::multimap<int, double, C, A> m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A(7)); assert(mo.get_allocator() == A(7));
Show All 9 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multimap<int, double, C, A> m = mo; std::multimap<int, double, C, A> m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A(-2)); assert(m.get_allocator() == A(-2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A(7)); assert(mo.get_allocator() == A(7));
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
V(1, 1), V(1, 1),
V(1, 1.5), V(1, 1.5),
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::multimap<int, double, C, A> m = mo; std::multimap<int, double, C, A> m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A()); assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp

Show All 30 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multimap<int, double, C, A> m(mo, A(3)); std::multimap<int, double, C, A> m(mo, A(3));
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A(3)); assert(m.get_allocator() == A(3));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A(7)); assert(mo.get_allocator() == A(7));
Show All 9 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::multimap<int, double, C, A> m(mo, A()); std::multimap<int, double, C, A> m(mo, A());
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A()); assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
} }
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
V(1, 1), V(1, 1),
V(1, 1.5), V(1, 1.5),
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef explicit_allocator<V> A; typedef explicit_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{}); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
std::multimap<int, double, C, A> m(mo, A{}); std::multimap<int, double, C, A> m(mo, A{});
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A{}); assert(m.get_allocator() == A{});
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A{}); assert(mo.get_allocator() == A{});
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp

Show All 30 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
Show All 29 Linesint main(int, char**)
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A(2)); assert(m.get_allocator() == A(2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
Show All 10 Lines#if TEST_STD_VER >= 11
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A()); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
m = mo; m = mo;
assert(m == mo); assert(m == mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A()); assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp

Show All 17 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef std::multimap<int, double, Cmp> C; typedef std::multimap<int, double, Cmp> C;
typedef C::value_type V; typedef C::value_type V;
C m( C m(
{ {
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
Show All 15 Linesint main(int, char**)
assert(*++i == V(2, 1.5)); assert(*++i == V(2, 1.5));
assert(*++i == V(2, 2)); assert(*++i == V(2, 2));
assert(*++i == V(3, 1)); assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5)); assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2)); assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4)); assert(m.key_comp() == Cmp(4));
} }
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef std::multimap<int, double, Cmp, min_allocator<std::pair<const int, double>>> C; typedef std::multimap<int, double, Cmp, min_allocator<std::pair<const int, double>>> C;
typedef C::value_type V; typedef C::value_type V;
C m( C m(
{ {
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
Show All 25 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef test_allocator<std::pair<const int, double> > A; typedef test_allocator<std::pair<const int, double> > A;
typedef std::multimap<int, double, Cmp, A> C; typedef std::multimap<int, double, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m( C m(
{ {
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
Show All 17 Linesint main(int, char**)
assert(*++i == V(2, 2)); assert(*++i == V(2, 2));
assert(*++i == V(3, 1)); assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5)); assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2)); assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4)); assert(m.key_comp() == Cmp(4));
assert(m.get_allocator() == A(5)); assert(m.get_allocator() == A(5));
} }
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef min_allocator<std::pair<const int, double> > A; typedef min_allocator<std::pair<const int, double> > A;
typedef std::multimap<int, double, Cmp, A> C; typedef std::multimap<int, double, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m( C m(
{ {
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
Show All 17 Linesint main(int, char**)
assert(*++i == V(2, 2)); assert(*++i == V(2, 2));
assert(*++i == V(3, 1)); assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5)); assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2)); assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4)); assert(m.key_comp() == Cmp(4));
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
} }
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef std::multimap<int, double, C, A> M; typedef std::multimap<int, double, C, A> M;
A a; A a;
M m ({ {1, 1}, M m ({ {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
{2, 1}, {2, 1},
Show All 14 Linesint main(int, char**)
assert(*++i == V(2, 1.5)); assert(*++i == V(2, 1.5));
assert(*++i == V(2, 2)); assert(*++i == V(2, 2));
assert(*++i == V(3, 1)); assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5)); assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2)); assert(*++i == V(3, 2));
assert(m.get_allocator() == a); assert(m.get_allocator() == a);
} }
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef explicit_allocator<std::pair<const int, double> > A; typedef explicit_allocator<std::pair<const int, double> > A;
typedef std::multimap<int, double, Cmp, A> C; typedef std::multimap<int, double, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m( C m(
{ {
{1, 1}, {1, 1},
{1, 1.5}, {1, 1.5},
{1, 2}, {1, 2},
Show All 27 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp

Show All 31 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::multimap<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5)); std::multimap<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 2) == V(1, 2));
assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 3) == V(2, 1));
Show All 13 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
std::multimap<int, double, C, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5)); std::multimap<int, double, C, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 2) == V(1, 2));
assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 3) == V(2, 1));
Show All 10 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp

Show All 32 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
Show All 15 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
Show All 14 Lines V ar[] =
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef explicit_allocator<V> A; typedef explicit_allocator<V> A;
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{}); std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
assert(m.get_allocator() == A{}); assert(m.get_allocator() == A{});
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
Show All 12 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp

Show All 20 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> mo(C(5), A(7)); std::multimap<int, double, C, A> mo(C(5), A(7));
std::multimap<int, double, C, A> m = std::move(mo); std::multimap<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 10 Lines typedef std::pair<const int, double> V;
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multimap<int, double, C, A> m = std::move(mo); std::multimap<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5)); assert(*next(m.begin()) == V(1, 1.5));
assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 2) == V(1, 2));
assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 3) == V(2, 1));
assert(*next(m.begin(), 4) == V(2, 1.5)); assert(*next(m.begin(), 4) == V(2, 1.5));
assert(*next(m.begin(), 5) == V(2, 2)); assert(*next(m.begin(), 5) == V(2, 2));
assert(*next(m.begin(), 6) == V(3, 1)); assert(*next(m.begin(), 6) == V(3, 1));
assert(*next(m.begin(), 7) == V(3, 1.5)); assert(*next(m.begin(), 7) == V(3, 1.5));
assert(*next(m.begin(), 8) == V(3, 2)); assert(*next(m.begin(), 8) == V(3, 2));
assert(mo.get_allocator() == A(test_alloc_base::moved_value)); assert(mo.get_allocator() == A(test_alloc_base::moved_value));
assert(mo.key_comp() == C(5)); assert(mo.key_comp() == C(5));
assert(mo.size() == 0); assert(mo.size() == 0);
assert(distance(mo.begin(), mo.end()) == 0); assert(distance(mo.begin(), mo.end()) == 0);
} }
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> mo(C(5), A()); std::multimap<int, double, C, A> mo(C(5), A());
std::multimap<int, double, C, A> m = std::move(mo); std::multimap<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 10 Lines typedef std::pair<const int, double> V;
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
V(2, 1.5), V(2, 1.5),
V(2, 2), V(2, 2),
V(3, 1), V(3, 1),
V(3, 1.5), V(3, 1.5),
V(3, 2), V(3, 2),
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::multimap<int, double, C, A> m = std::move(mo); std::multimap<int, double, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
Show All 17 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp

Show All 23 Lines
#include "min_allocator.h" #include "min_allocator.h"
#include "Counter.h" #include "Counter.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<VC> A; typedef other_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Linesint main(int, char**)
assert(Counter_base::gConstructed >= (int)(2*num)); assert(Counter_base::gConstructed >= (int)(2*num));
assert(Counter_base::gConstructed <= (int)(4*num)); assert(Counter_base::gConstructed <= (int)(4*num));
} }
assert(Counter_base::gConstructed == 0); assert(Counter_base::gConstructed == 0);
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<VC> A; typedef min_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 22 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A()); assert(m3.get_allocator() == A());
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef explicit_allocator<VC> A; typedef explicit_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 30 Lines

libcxx/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp

Show All 22 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<VC> A; typedef test_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<VC> A; typedef other_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 23 Linesint main(int, char**)
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef std::pair<MoveOnly, MoveOnly> V; typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC; typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<VC> A; typedef min_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M; typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1, 1), V(1, 1),
V(1, 2), V(1, 2),
V(1, 3), V(1, 3),
Show All 31 Lines

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

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines typedef std::multimap<int, double> M;
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);
} }
} }
{ {
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
Show All 17 Lines typedef std::multimap<int, double> M;
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator().get_id() == 1); assert(m1.get_allocator().get_id() == 1);
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator().get_id() == 2); assert(m2.get_allocator().get_id() == 2);
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
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);
} }
} }
{ {
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_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),
V(2, 2), V(2, 2),
V(3, 3), V(3, 3),
V(4, 4) V(4, 4)
}; };
Show All 27 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp

Show All 18 Lines
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::multiset<int, C> m(C(3)); const std::multiset<int, C> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
assert(m.value_comp() == C(3)); assert(m.value_comp() == C(3));
return 0; return 0;
} }

libcxx/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp

Show All 15 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<int> A; typedef test_allocator<int> A;
std::multiset<int, C, A> m(C(4), A(5)); std::multiset<int, C, A> m(C(4), A(5));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A(5)); assert(m.get_allocator() == A(5));
return 0; return 0;
} }

libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp

Show All 29 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multiset<int, C, A> m = mo; std::multiset<int, C, A> m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
Show All 30 Lines#if TEST_STD_VER >= 11
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multiset<int, C, A> m = mo; std::multiset<int, C, A> m = mo;
assert(m.get_allocator() == A(-2)); assert(m.get_allocator() == A(-2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
Show All 27 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp

Show All 28 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multiset<int, C, A> m(mo, A(3)); std::multiset<int, C, A> m(mo, A(3));
assert(m.get_allocator() == A(3)); assert(m.get_allocator() == A(3));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
Show All 25 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp

Show All 29 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(2)); assert(m.get_allocator() == A(2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
Show All 27 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp

Show All 15 Lines
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef std::multiset<int, Cmp> C; typedef std::multiset<int, Cmp> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, Cmp(10)); C m({1, 2, 3, 4, 5, 6}, Cmp(10));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
assert(*++i == V(2)); assert(*++i == V(2));
assert(*++i == V(3)); assert(*++i == V(3));
assert(*++i == V(4)); assert(*++i == V(4));
assert(*++i == V(5)); assert(*++i == V(5));
assert(*++i == V(6)); assert(*++i == V(6));
assert(m.key_comp() == Cmp(10)); assert(m.key_comp() == Cmp(10));
return 0; return 0;
} }

libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp

Show All 16 Lines
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::multiset<int, Cmp, A> C; typedef std::multiset<int, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4)); C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
Show All 10 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp

Show All 32 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_less<V> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar), std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar),
cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7)); C(5), A(7));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
Show All 18 Lines V ar[] =
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
A a; A a;
std::multiset<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a); std::multiset<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
Show All 12 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp

Show All 29 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_less<V> C;
std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar), std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar),
cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5)); cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
Show All 9 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp

Show All 20 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<int, C, A> mo(C(5), A(7)); std::multiset<int, C, A> mo(C(5), A(7));
std::multiset<int, C, A> m = std::move(mo); std::multiset<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 11 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::multiset<int, C, A> m = std::move(mo); std::multiset<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
Show All 20 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::multiset<int, C, A> m = std::move(mo); std::multiset<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
Show All 17 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp

Show All 21 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "Counter.h" #include "Counter.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 21 Linesint main(int, char**)
M m3(std::move(m1), A(7)); M m3(std::move(m1), A(7));
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 21 Linesint main(int, char**)
M m3(std::move(m1), A(5)); M m3(std::move(m1), A(5));
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp

Show All 21 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef std::multiset<MoveOnly, C, A> M; typedef std::multiset<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 31 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines typedef std::multiset<int> M;
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);
} }
} }
{ {
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
2, 2,
3, 3,
4 4
}; };
Show All 17 Lines typedef std::multiset<int> M;
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator().get_id() == 1); assert(m1.get_allocator().get_id() == 1);
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator().get_id() == 2); assert(m2.get_allocator().get_id() == 2);
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
2, 2,
3, 3,
4 4
}; };
Show All 26 Lines

libcxx/test/std/containers/associative/set/set.cons/compare.pass.cpp

Show All 18 Lines
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
const std::set<int, C> m(C(3)); const std::set<int, C> m(C(3));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(3)); assert(m.key_comp() == C(3));
assert(m.value_comp() == C(3)); assert(m.value_comp() == C(3));
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp

Show All 15 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<int> A; typedef test_allocator<int> A;
std::set<int, C, A> m(C(4), A(5)); std::set<int, C, A> m(C(4), A(5));
assert(m.empty()); assert(m.empty());
assert(m.begin() == m.end()); assert(m.begin() == m.end());
assert(m.key_comp() == C(4)); assert(m.key_comp() == C(4));
assert(m.get_allocator() == A(5)); assert(m.get_allocator() == A(5));
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp

Show All 29 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::set<int, C, A> m = mo; std::set<int, C, A> m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
Show All 18 Lines#if TEST_STD_VER >= 11
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::set<int, C, A> m = mo; std::set<int, C, A> m = mo;
assert(m.get_allocator() == A(-2)); assert(m.get_allocator() == A(-2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
Show All 15 Lines

libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp

Show All 28 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::set<int, C, A> m(mo, A(3)); std::set<int, C, A> m(mo, A(3));
assert(m.get_allocator() == A(3)); assert(m.get_allocator() == A(3));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
Show All 13 Lines

libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp

Show All 29 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 33 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7)); std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
m = mo; m = mo;
assert(m.get_allocator() == A(2)); assert(m.get_allocator() == A(2));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 15 Lines

libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp

Show All 15 Lines
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
int main(int, char**) int main(int, char**)
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef std::set<int, Cmp> C; typedef std::set<int, Cmp> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, Cmp(10)); C m({1, 2, 3, 4, 5, 6}, Cmp(10));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
assert(*++i == V(2)); assert(*++i == V(2));
assert(*++i == V(3)); assert(*++i == V(3));
assert(*++i == V(4)); assert(*++i == V(4));
assert(*++i == V(5)); assert(*++i == V(5));
assert(*++i == V(6)); assert(*++i == V(6));
assert(m.key_comp() == Cmp(10)); assert(m.key_comp() == Cmp(10));
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp

Show All 18 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::set<int, Cmp, A> C; typedef std::set<int, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4)); C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
assert(*++i == V(2)); assert(*++i == V(2));
assert(*++i == V(3)); assert(*++i == V(3));
assert(*++i == V(4)); assert(*++i == V(4));
assert(*++i == V(5)); assert(*++i == V(5));
assert(*++i == V(6)); assert(*++i == V(6));
assert(m.key_comp() == Cmp(10)); assert(m.key_comp() == Cmp(10));
assert(m.get_allocator() == A(4)); assert(m.get_allocator() == A(4));
} }
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_less<int> Cmp;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::set<int, Cmp, A> C; typedef std::set<int, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, A(4)); C m({1, 2, 3, 4, 5, 6}, A(4));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
Show All 10 Lines

libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp

Show All 36 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_less<V> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar), std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar),
cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7)); C(5), A(7));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
Show All 12 Lines V ar[] =
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
A a(7); A a(7);
std::set<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a); std::set<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
assert(m.get_allocator() == a); assert(m.get_allocator() == a);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp

Show All 29 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_less<V> C;
std::set<V, C> m(cpp17_input_iterator<const V*>(ar), std::set<V, C> m(cpp17_input_iterator<const V*>(ar),
cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5)); cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp

Show All 20 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<int, C, A> mo(C(5), A(7)); std::set<int, C, A> mo(C(5), A(7));
std::set<int, C, A> m = std::move(mo); std::set<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 0); assert(m.size() == 0);
assert(distance(m.begin(), m.end()) == 0); assert(distance(m.begin(), m.end()) == 0);
Show All 11 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7)); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
std::set<int, C, A> m = std::move(mo); std::set<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
Show All 14 Linesint main(int, char**)
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A()); std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
std::set<int, C, A> m = std::move(mo); std::set<int, C, A> m = std::move(mo);
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
Show All 11 Lines

libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp

Show All 21 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "Counter.h" #include "Counter.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 21 Linesint main(int, char**)
M m3(std::move(m1), A(7)); M m3(std::move(m1), A(7));
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 21 Linesint main(int, char**)
M m3(std::move(m1), A(5)); M m3(std::move(m1), A(5));
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/test/std/containers/associative/set/set.cons/move_assign.pass.cpp

Show All 21 Lines
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(5)); assert(m3.get_allocator() == A(5));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 22 Linesint main(int, char**)
m3 = std::move(m1); m3 = std::move(m1);
assert(m3 == m2); assert(m3 == m2);
assert(m3.get_allocator() == A(7)); assert(m3.get_allocator() == A(7));
assert(m3.key_comp() == C(5)); assert(m3.key_comp() == C(5));
assert(m1.empty()); assert(m1.empty());
} }
{ {
typedef MoveOnly V; typedef MoveOnly V;
typedef test_compare<std::less<MoveOnly> > C; typedef test_less<MoveOnly> C;
typedef min_allocator<V> A; typedef min_allocator<V> A;
typedef std::set<MoveOnly, C, A> M; typedef std::set<MoveOnly, C, A> M;
typedef std::move_iterator<V*> I; typedef std::move_iterator<V*> I;
V a1[] = V a1[] =
{ {
V(1), V(1),
V(1), V(1),
V(1), V(1),
Show All 31 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines typedef std::set<int> M;
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);
} }
} }
{ {
typedef test_allocator<V> A; typedef test_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
2, 2,
3, 3,
4 4
}; };
Show All 17 Lines typedef std::set<int> M;
assert(m2 == m1_save); assert(m2 == m1_save);
assert(m1.key_comp() == C(2)); assert(m1.key_comp() == C(2));
assert(m1.get_allocator().get_id() == 1); assert(m1.get_allocator().get_id() == 1);
assert(m2.key_comp() == C(1)); assert(m2.key_comp() == C(1));
assert(m2.get_allocator().get_id() == 2); assert(m2.get_allocator().get_id() == 2);
} }
{ {
typedef other_allocator<V> A; typedef other_allocator<V> A;
typedef test_compare<std::less<int> > C; typedef test_less<int> C;
typedef std::set<int, C, A> M; typedef std::set<int, C, A> M;
V ar1[] = V ar1[] =
{ {
1, 1,
2, 2,
3, 3,
4 4
}; };
Show All 26 Lines

libcxx/test/std/containers/test_compare.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef TEST_COMPARE_H #ifndef TEST_COMPARE_H
#define TEST_COMPARE_H #define TEST_COMPARE_H
#include <cstddef> template <class T>
#include <type_traits> struct test_equal_to
#include <cstdlib>
#include <new>
#include <climits>
template <class C>
class test_compare
: private C
{ {
int data_; int data_;
public: explicit test_equal_to() : data_(0) {}
explicit test_compare(int data = 0) : data_(data) {} explicit test_equal_to(int data) : data_(data) {}
bool operator()(const T& a, const T& b) const
typename C::result_type { return a == b; }
operator()(typename std::add_lvalue_reference<const typename C::first_argument_type>::type x, friend bool operator==(const test_equal_to& a, const test_equal_to& b)
typename std::add_lvalue_reference<const typename C::second_argument_type>::type y) const { return a.data_ == b.data_; }
{return C::operator()(x, y);}
bool operator==(const test_compare& c) const
{return data_ == c.data_;}
}; };
template <class T>
template <class C> struct test_less
class non_const_compare
{ {
// operator() deliberately not marked as 'const' int data_;
bool operator()(const C& x, const C& y) { return x < y; } explicit test_less() : data_(0) {}
explicit test_less(int data) : data_(data) {}
bool operator()(const T& a, const T& b) const
{ return a < b; }
friend bool operator==(const test_less& a, const test_less& b)
{ return a.data_ == b.data_; }
}; };
#endif // TEST_COMPARE_H #endif // TEST_COMPARE_H

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

Show All 23 Lines
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)); C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{}); C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
C c(A{}); C c(A{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A; typedef test_allocator<std::pair<const T, T>> A;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef std::unordered_map<T, T, HF, Comp, A> C; typedef std::unordered_map<T, T, HF, Comp, A> C;
A a(10); A a(10);
C c(2, a); C c(2, a);
LIBCPP_ASSERT(c.bucket_count() == 2); LIBCPP_ASSERT(c.bucket_count() == 2);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A; typedef test_allocator<std::pair<const T, T>> A;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef std::unordered_map<T, T, HF, Comp, A> C; typedef std::unordered_map<T, T, HF, Comp, A> C;
A a(10); A a(10);
HF hf(12); HF hf(12);
C c(2, hf, a); C c(2, hf, a);
LIBCPP_ASSERT(c.bucket_count() == 2); LIBCPP_ASSERT(c.bucket_count() == 2);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == HF())); assert(!(c.hash_function() == HF()));
Show All 13 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
Show All 13 Linesint main(int, char**)
c = *p; c = *p;
assert(c.size() == 4); assert(c.size() == 4);
assert(std::is_permutation(c.begin(), c.end(), a)); assert(std::is_permutation(c.begin(), c.end(), a));
} }
{ {
typedef other_allocator<std::pair<const int, std::string> > A; typedef other_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::allocator<std::pair<const int, std::string> > A; typedef std::allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
Show All 15 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
Show All 22 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp

Show All 29 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(10) A(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.size() == 0); assert(c0.size() == 0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef other_allocator<std::pair<const int, std::string> > A; typedef other_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.size() == 0); assert(c0.size() == 0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.size() == 0); assert(c0.size() == 0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp

Show All 26 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
other_allocator<std::pair<const int, std::string> > other_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
other_allocator<std::pair<const int, std::string> >(10) other_allocator<std::pair<const int, std::string> >(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(other_allocator<std::pair<const int, std::string> >(-2))); (other_allocator<std::pair<const int, std::string> >(-2)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp

Show All 26 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C c(c0, test_allocator<std::pair<const int, std::string> >(5)); C c(c0, test_allocator<std::pair<const int, std::string> >(5));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(5))); (test_allocator<std::pair<const int, std::string> >(5)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C c(c0, min_allocator<std::pair<const int, std::string> >()); C c(c0, min_allocator<std::pair<const int, std::string> >());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
C c(c0, A{}); C c(c0, A{});
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
{ {
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
A a; A a;
C c(a); C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
} }
Show All 13 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
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"),
}; };
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
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"),
}; };
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
A a(42); A a(42);
C c ( { C c ( {
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"),
}, 12, a); }, 12, a);
assert(c.bucket_count() >= 12); assert(c.bucket_count() >= 12);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
HF hf(42); HF hf(42);
A a(43); A a(43);
C c ( { C c ( {
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"),
}, 12, hf, a); }, 12, hf, a);
assert(c.bucket_count() >= 12); assert(c.bucket_count() >= 12);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == test_hash<std::hash<int> >())); assert(!(c.hash_function() == test_hash<std::hash<int> >()));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif // TEST_STD_VER > 11 #endif // TEST_STD_VER > 11
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp

Show All 30 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(12)); C c(std::move(c0), A(12));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(12)); assert(c.get_allocator() == A(12));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(10)); C c(std::move(c0), A(10));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef min_allocator<std::pair<const int, std::string>> A; typedef min_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
C c(std::move(c0), A{}); C c(std::move(c0), A{});
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 15 Lines#if TEST_STD_VER > 11
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 27 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >())); (test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

Show All 31 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string, typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.compile.fail.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
typedef std::unordered_map<NotConstructible, NotConstructible, typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

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

Show All 23 Lines
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 33 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 27 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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"),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show All 25 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 39 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 39 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 39 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)); C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{}); C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
C c(A{}); C c(A{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A; typedef test_allocator<std::pair<const T, T>> A;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef std::unordered_multimap<T, T, HF, Comp, A> C; typedef std::unordered_multimap<T, T, HF, Comp, A> C;
A a(10); A a(10);
C c(2, a); C c(2, a);
LIBCPP_ASSERT(c.bucket_count() == 2); LIBCPP_ASSERT(c.bucket_count() == 2);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A; typedef test_allocator<std::pair<const T, T>> A;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef std::unordered_multimap<T, T, HF, Comp, A> C; typedef std::unordered_multimap<T, T, HF, Comp, A> C;
A a(10); A a(10);
HF hf(12); HF hf(12);
C c(2, hf, a); C c(2, hf, a);
LIBCPP_ASSERT(c.bucket_count() == 2); LIBCPP_ASSERT(c.bucket_count() == 2);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == HF())); assert(!(c.hash_function() == HF()));
Show All 13 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp

Show All 30 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
Show All 13 Linesint main(int, char**)
c = *p; c = *p;
assert(c.size() == 6); assert(c.size() == 6);
assert(std::is_permutation(c.begin(), c.end(), a)); assert(std::is_permutation(c.begin(), c.end(), a));
} }
{ {
typedef other_allocator<std::pair<const int, std::string> > A; typedef other_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp

Show All 31 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
Show All 34 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp

Show All 31 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 21 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef test_allocator<std::pair<const int, std::string> > A; typedef test_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(10) A(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 23 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef other_allocator<std::pair<const int, std::string> > A; typedef other_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 23 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef min_allocator<std::pair<const int, std::string> > A; typedef min_allocator<std::pair<const int, std::string> > A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 30 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
other_allocator<std::pair<const int, std::string> > other_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
other_allocator<std::pair<const int, std::string> >(10) other_allocator<std::pair<const int, std::string> >(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(other_allocator<std::pair<const int, std::string> >(-2))); (other_allocator<std::pair<const int, std::string> >(-2)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C c(c0, test_allocator<std::pair<const int, std::string> >(5)); C c(c0, test_allocator<std::pair<const int, std::string> >(5));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(5))); (test_allocator<std::pair<const int, std::string> >(5)));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C c(c0, min_allocator<std::pair<const int, std::string> >()); C c(c0, min_allocator<std::pair<const int, std::string> >());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
C c(c0, A{}); C c(c0, A{});
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
s.insert("two"); s.insert("two");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s); CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
s.insert("three"); s.insert("three");
CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s); CheckConsecutiveKeys<C::const_iterator>(c.find(3), c.end(), 3, s);
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s); CheckConsecutiveKeys<C::const_iterator>(c.find(4), c.end(), 4, s);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
{ {
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
A a; A a;
C c(a); C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
} }
Show All 13 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 25 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c = { C c = {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 25 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
A a(42); A a(42);
C c ({ C c ({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 33 Lines#if TEST_STD_VER > 11
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A())); assert(!(c.get_allocator() == A()));
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
HF hf(42); HF hf(42);
A a(43); A a(43);
C c ({ C c ({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 27 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 27 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 28 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 28 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp

Show All 31 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
Show All 15 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
Show All 15 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp

Show All 31 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c({ C c({
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"),
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp

Show All 30 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10))); (test_allocator<std::pair<const int, std::string> >(10)));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 19 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 19 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp

Show All 32 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(12)); C c(std::move(c0), A(12));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 17 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12))); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12)));
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(10)); C c(std::move(c0), A(10));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 17 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef min_allocator<std::pair<const int, std::string>> A; typedef min_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 17 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 17 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

Show All 31 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 27 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 27 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
Show All 35 Lines#if TEST_STD_VER > 11
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A())); assert(!(c.get_allocator() == A()));
} }
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_equal_to<int> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

Show All 31 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 29 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 29 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

Show All 32 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 30 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
Show All 30 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

Show All 32 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
Show All 15 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
Show All 15 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

Show All 33 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<std::pair<const int, std::string> > test_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Linesint main(int, char**)
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<std::pair<const int, std::string> > min_allocator<std::pair<const int, std::string> >
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
{ {
typedef explicit_allocator<std::pair<const int, std::string>> A; typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string, typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 16 Lines#if TEST_STD_VER >= 11
i = eq.first; i = eq.first;
assert(i->first == 4); assert(i->first == 4);
assert(i->second == "four"); assert(i->second == "four");
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.compile.fail.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >())); (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const NotConstructible, NotConstructible> >())); (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A; typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
typedef std::unordered_multimap<NotConstructible, NotConstructible, typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

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

Show All 25 Lines
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 33 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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"),
Show All 32 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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"),
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint main(int, char**)
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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
Show All 30 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_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"),
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
Show All 30 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_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"),
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

Show All 22 Lines
#include "../../test_hash.h" #include "../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(test_allocator<NotConstructible>(10)); C c(test_allocator<NotConstructible>(10));
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == test_allocator<NotConstructible>(10)); assert(c.get_allocator() == test_allocator<NotConstructible>(10));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(min_allocator<NotConstructible>{}); C c(min_allocator<NotConstructible>{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == min_allocator<NotConstructible>()); assert(c.get_allocator() == min_allocator<NotConstructible>());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
A a(43); A a(43);
C c(3, a); C c(3, a);
LIBCPP_ASSERT(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp ()); assert(c.key_eq() == Comp ());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A())); assert(!(c.get_allocator() == A()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
HF hf(42); HF hf(42);
A a(43); A a(43);
C c(4, hf, a); C c(4, hf, a);
LIBCPP_ASSERT(c.bucket_count() == 4); LIBCPP_ASSERT(c.bucket_count() == 4);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
Show All 15 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
Show All 14 Linesint main(int, char**)
assert(c.size() == 6); assert(c.size() == 6);
assert(std::is_permutation(c.begin(), c.end(), a)); assert(std::is_permutation(c.begin(), c.end(), a));
} }
{ {
typedef other_allocator<int> A; typedef other_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
Show All 15 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
Show All 22 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp

Show All 29 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(10) A(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef other_allocator<int> A; typedef other_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp

Show All 26 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
other_allocator<int> other_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
other_allocator<int>(10) other_allocator<int>(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == other_allocator<int>(-2)); assert(c.get_allocator() == other_allocator<int>(-2));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp

Show All 26 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c(c0, test_allocator<int>(5)); C c(c0, test_allocator<int>(5));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(5)); assert(c.get_allocator() == test_allocator<int>(5));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c(c0, min_allocator<int>()); C c(c0, min_allocator<int>());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<NotConstructible> A; typedef explicit_allocator<NotConstructible> A;
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
{ {
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
A a; A a;
C c(a); C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
} }
Show All 13 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
A a(42); A a(42);
C c({ C c({
T(1), T(1),
T(2), T(2),
T(3), T(3),
Show All 16 Lines#if TEST_STD_VER > 11
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
A a(42); A a(42);
HF hf(43); HF hf(43);
C c({ C c({
T(1), T(1),
T(2), T(2),
Show All 27 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp

Show All 30 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int P; typedef int P;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(12)); C c(std::move(c0), A(12));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2); CheckConsecutiveValues<C::const_iterator>(c.find(1), c.end(), 1, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2); CheckConsecutiveValues<C::const_iterator>(c.find(2), c.end(), 2, 2);
CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1); CheckConsecutiveValues<C::const_iterator>(c.find(3), c.end(), 3, 1);
CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1); CheckConsecutiveValues<C::const_iterator>(c.find(4), c.end(), 4, 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(12)); assert(c.get_allocator() == A(12));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef int P; typedef int P;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(10)); C c(std::move(c0), A(10));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef int P; typedef int P;
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef int P; typedef int P;
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
Show All 16 Lines#if TEST_STD_VER > 11
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
Show All 28 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, typedef std::unordered_multiset<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.compile.fail.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (test_allocator<NotConstructible>(10))); assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<NotConstructible, typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

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

Show All 22 Lines
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 33 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 27 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show All 22 Lines
#include "../../test_hash.h" #include "../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(test_allocator<NotConstructible>(10)); C c(test_allocator<NotConstructible>(10));
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == test_allocator<NotConstructible>(10)); assert(c.get_allocator() == test_allocator<NotConstructible>(10));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(min_allocator<NotConstructible>{}); C c(min_allocator<NotConstructible>{});
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == min_allocator<NotConstructible>()); assert(c.get_allocator() == min_allocator<NotConstructible>());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
A a(43); A a(43);
C c(3, a); C c(3, a);
LIBCPP_ASSERT(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp ()); assert(c.key_eq() == Comp ());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A())); assert(!(c.get_allocator() == A()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
HF hf(42); HF hf(42);
A a(43); A a(43);
C c(4, hf, a); C c(4, hf, a);
LIBCPP_ASSERT(c.bucket_count() == 4); LIBCPP_ASSERT(c.bucket_count() == 4);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
Show All 15 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp

Show All 27 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
Show All 13 Linesint main(int, char**)
c = *p; c = *p;
assert(c.size() == 4); assert(c.size() == 4);
assert(std::is_permutation(c.begin(), c.end(), a)); assert(std::is_permutation(c.begin(), c.end(), a));
} }
{ {
typedef other_allocator<int> A; typedef other_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
c = c0; c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
Show All 15 Linesint main(int, char**)
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
Show All 22 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp

Show All 28 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(10) A(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef other_allocator<int> A; typedef other_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A(4) A(4)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
{ {
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(a, a + 2, C c(a, a + 2,
7, 7,
test_hash<std::hash<int> >(2), test_hash<std::hash<int> >(2),
test_compare<std::equal_to<int> >(3), test_equal_to<int>(3),
A() A()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
c = std::move(c0); c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp

Show All 25 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
other_allocator<int> other_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
other_allocator<int>(10) other_allocator<int>(10)
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == other_allocator<int>(-2)); assert(c.get_allocator() == other_allocator<int>(-2));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c = c0; C c = c0;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp

Show All 25 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c(c0, test_allocator<int>(5)); C c(c0, test_allocator<int>(5));
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(5)); assert(c.get_allocator() == test_allocator<int>(5));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c(c0, min_allocator<int>()); C c(c0, min_allocator<int>());
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef explicit_allocator<NotConstructible> A; typedef explicit_allocator<NotConstructible> A;
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
A A
> C; > C;
{ {
C c; C c;
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
A a; A a;
C c(a); C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == a); assert(c.get_allocator() == a);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
} }
Show All 13 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c = { C c = {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
A a(42); A a(42);
C c({ C c({
T(1), T(1),
T(2), T(2),
T(3), T(3),
Show All 16 Lines#if TEST_STD_VER > 11
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
A a(42); A a(42);
HF hf(43); HF hf(43);
C c({ C c({
T(1), T(1),
T(2), T(2),
Show All 27 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
C c({ C c({
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
C c0(7, C c0(7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 0); assert(c.size() == 0);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(c.empty()); assert(c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
C::iterator it0 = c0.begin(); C::iterator it0 = c0.begin();
C c = std::move(c0); C c = std::move(c0);
assert(it0 == c.begin()); // Iterators remain valid assert(it0 == c.begin()); // Iterators remain valid
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp

Show All 29 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int P; typedef int P;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(12)); C c(std::move(c0), A(12));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(12)); assert(c.get_allocator() == A(12));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef int P; typedef int P;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A(10) A(10)
); );
C c(std::move(c0), A(10)); C c(std::move(c0), A(10));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
{ {
typedef int P; typedef int P;
typedef min_allocator<int> A; typedef min_allocator<int> A;
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
A A
> C; > C;
P a[] = P a[] =
{ {
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 c0(a, a + sizeof(a)/sizeof(a[0]), C c0(a, a + sizeof(a)/sizeof(a[0]),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c0.empty()); assert(c0.empty());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
Show All 16 Lines#if TEST_STD_VER > 11
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_equal_to<T> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
Show All 29 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp

Show All 27 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_equal_to<int>());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp

Show All 28 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_equal_to<int>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp

Show All 29 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
test_allocator<int> test_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, typedef std::unordered_set<int,
test_hash<std::hash<int> >, test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >, test_equal_to<int>,
min_allocator<int> min_allocator<int>
> C; > C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
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 c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_equal_to<int>(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8)); assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); assert(c.key_eq() == test_equal_to<int>(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.compile.fail.cpp

Show All 22 Lines
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8) test_hash<std::hash<NotConstructible> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9) test_equal_to<NotConstructible>(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp

Show All 23 Lines
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
test_allocator<NotConstructible>(10) test_allocator<NotConstructible>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (test_allocator<NotConstructible>(10))); assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >, test_equal_to<NotConstructible>,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7, C c(7,
test_hash<std::hash<NotConstructible> >(8), test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9), test_equal_to<NotConstructible>(9),
min_allocator<NotConstructible>() min_allocator<NotConstructible>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.key_eq() == test_equal_to<NotConstructible>(9));
assert(c.get_allocator() == (min_allocator<NotConstructible>())); assert(c.get_allocator() == (min_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#endif #endif
return 0; return 0;
} }

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

Show All 22 Lines
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 33 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_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),
Show All 27 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_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),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
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);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
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);
Show All 11 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 31 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
Show All 25 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_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),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
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);
Show All 11 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
Show All 25 Lines#if TEST_STD_VER >= 11
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.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_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_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),
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp

Show All 39 Lines
template <class ValueT, class Del> template <class ValueT, class Del>
void test_disabled_with_deleter() { void test_disabled_with_deleter() {
using UPtr = std::unique_ptr<ValueT, Del>; using UPtr = std::unique_ptr<ValueT, Del>;
using pointer = typename UPtr::pointer; using pointer = typename UPtr::pointer;
test_hash_disabled_for_type<UPtr>(); test_hash_disabled_for_type<UPtr>();
test_hash_disabled_for_type<pointer>(); test_hash_disabled_for_type<pointer>();
} }
namespace std {
template <class T> template <class T>
struct hash<::min_pointer<T, std::integral_constant<size_t, 1>>> { struct std::hash<min_pointer<T, std::integral_constant<size_t, 1>>> {
size_t operator()(::min_pointer<T, std::integral_constant<size_t, 1>> p) const TEST_NOEXCEPT_FALSE { size_t operator()(min_pointer<T, std::integral_constant<size_t, 1>> p) const TEST_NOEXCEPT_FALSE {
if (!p) return 0; if (!p) return 0;
return std::hash<T*>{}(std::addressof(*p)); return std::hash<T*>{}(std::addressof(*p));
} }
}; };
}
struct A {}; struct A {};
#endif // TEST_STD_VER >= 11 #endif // TEST_STD_VER >= 11
int main(int, char**) int main(int, char**)
{ {
{ {
Show All 39 Lines

libcxx/test/support/min_allocator.h

Show First 20 Lines • Show All 366 Lines • ▼ Show 20 Linespublic:
friend TEST_CONSTEXPR_CXX14 bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;} friend TEST_CONSTEXPR_CXX14 bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator> (min_pointer x, min_pointer y) {return y < x;} friend TEST_CONSTEXPR_CXX14 bool operator> (min_pointer x, min_pointer y) {return y < x;}
friend TEST_CONSTEXPR_CXX14 bool operator<=(min_pointer x, min_pointer y) {return !(y < x);} friend TEST_CONSTEXPR_CXX14 bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
friend TEST_CONSTEXPR_CXX14 bool operator>=(min_pointer x, min_pointer y) {return !(x < y);} friend TEST_CONSTEXPR_CXX14 bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}
static TEST_CONSTEXPR_CXX14 min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));} static TEST_CONSTEXPR_CXX14 min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));}
friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;} friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return !(x == y);} friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return x.ptr_ != y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, std::nullptr_t) {return x.ptr_ == nullptr;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, std::nullptr_t) {return x.ptr_ != nullptr;}
friend TEST_CONSTEXPR_CXX14 bool operator==(std::nullptr_t, min_pointer x) {return x.ptr_ == nullptr;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(std::nullptr_t, min_pointer x) {return x.ptr_ != nullptr;}
template <class U, class XID> friend class min_pointer; template <class U, class XID> friend class min_pointer;
}; };
template <class T, class ID>
TEST_CONSTEXPR_CXX14 inline
bool
operator==(min_pointer<T, ID> x, std::nullptr_t)
{
return !static_cast<bool>(x);
}
template <class T, class ID>
TEST_CONSTEXPR_CXX14 inline
bool
operator==(std::nullptr_t, min_pointer<T, ID> x)
{
return !static_cast<bool>(x);
}
template <class T, class ID>
TEST_CONSTEXPR_CXX14 inline
bool
operator!=(min_pointer<T, ID> x, std::nullptr_t)
{
return static_cast<bool>(x);
}
template <class T, class ID>
TEST_CONSTEXPR_CXX14 inline
bool
operator!=(std::nullptr_t, min_pointer<T, ID> x)
{
return static_cast<bool>(x);
}
template <class T> template <class T>
class min_allocator class min_allocator
{ {
public: public:
typedef T value_type; typedef T value_type;
typedef min_pointer<T> pointer; typedef min_pointer<T> pointer;
min_allocator() = default; min_allocator() = default;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines